ci.yml

name: CI

on:
  push:
    branches:
      - main
  workflow_dispatch:
  pull_request:
    types:
      - labeled
      - synchronize
      - opened

concurrency:
  group: ${{ github.workflow }}-${{ github.ref_name }}-${{ github.event.pull_request.number || github.sha }}
  cancel-in-progress: true

env:
  CARGO_INCREMENTAL: 0
  CARGO_NET_RETRY: 10
  RUSTUP_MAX_RETRIES: 10
  RUST_LOG: info
  RUST_BACKTRACE: 1
  RUSTFLAGS: "-D warnings"
  CARGO_TERM_COLOR: always
  CICD_INTERMEDIATES_DIR: "_cicd-intermediates"
  XDG_CACHE_HOME: ${{ github.workspace }}/.cache
  PYTEST_ADDOPTS: "--color=yes"

  #
  # Select a profile that is used for building the binary. The profile optimizes for certain use-cases.
  # For distribution builds we want to reduce the size of the binary as much as possible. Whereas in
  # regular CI builds we just want the fastest build possible.
  #
  # We switch based on the branch that is being built. If it's the main branch or a tag, we use the `dist`.
  #
  # Inspiration was taken from this blog: https://arusahni.net/blog/2020/03/optimizing-rust-binary-size.html
  #
  CARGO_BUILD_PROFILE: ci

jobs:
  # Check if the code has changed in such a way that a rebuild is needed.
  determine_changes:
    name: "determine changes"
    runs-on: ubuntu-latest
    outputs:
      # Flag that is raised when any code is changed
      code: ${{ steps.changed.outputs.code_any_changed }}
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - uses: tj-actions/changed-files@v45
        id: changed
        with:
          files_yaml: |
            code:
              - "**/*"
              - "!assets/**"
              - "!docs/**"
              - "docs/source_files/**"
              - "!install/**"
              - "!assets/**"
              - "!**/*.md"

  pre-commit:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Set up pixi
        uses: prefix-dev/setup-pixi@v0.8.3
        with:
          environments: lint
      - name: pre-commit
        run: pixi run pre-commit-run --color=always --show-diff-on-failure

  # Check that all the code references are correct.
  check-rustdoc-links:
    name: "cargo rustdoc | ubuntu"
    needs: determine_changes
    runs-on: ubuntu-latest
    if: ${{ needs.determine_changes.outputs.code == 'true' || github.ref == 'refs/heads/main' }}
    steps:
      - uses: actions/checkout@v4
      - uses: Swatinem/rust-cache@v2
        with:
          save-if: ${{ github.ref == 'refs/heads/main' }}
      - run: |
          for package in $(cargo metadata --no-deps --format-version=1 | jq -r '.packages[] | .name'); do
            cargo rustdoc -p "$package" --all-features -- -D warnings -W unreachable-pub
          done

  # Checks for dependencies that are not used in the codebase
  cargo-machete:
    name: Cargo Machete
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v4
      - name: Machete
        uses: bnjbvr/cargo-machete@v0.7.1

  # Checks for duplicate version of package
  cargo-vendor:
    name: Cargo Vendor
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: prefix-dev/setup-pixi@v0.8.3
        with:
          cache: ${{ github.ref == 'refs/heads/main' }}
      - uses: Swatinem/rust-cache@v2
        with:
          workspaces: ". -> target/pixi"
          key: ${{ hashFiles('pixi.lock') }}
          save-if: ${{ github.ref == 'refs/heads/main' }}
      - name: Test cargo vendor
        run: cargo vendor --locked

  #
  # Run tests on important platforms.
  #

  cargo-test-linux:
    name: "cargo test | ubuntu"
    timeout-minutes: 15
    needs: determine_changes
    if: ${{ needs.determine_changes.outputs.code == 'true' || github.ref == 'refs/heads/main' }}
    runs-on: 8core_ubuntu_latest_runner
    steps:
      - uses: actions/checkout@v4
      - uses: prefix-dev/setup-pixi@v0.8.3
        with:
          cache: ${{ github.ref == 'refs/heads/main' }}
      - uses: Swatinem/rust-cache@v2
        with:
          workspaces: ". -> target/pixi"
          key: ${{ hashFiles('pixi.lock') }}
          save-if: ${{ github.ref == 'refs/heads/main' }}
      - name: Test pixi
        run: pixi run test-slow
        env:
          PIXI_TEST_R2_ACCESS_KEY_ID: ${{ secrets.PIXI_TEST_R2_ACCESS_KEY_ID }}
          PIXI_TEST_R2_SECRET_ACCESS_KEY: ${{ secrets.PIXI_TEST_R2_SECRET_ACCESS_KEY }}

  cargo-test-macos-aarch64:
    name: "cargo test | macos aarch64"
    timeout-minutes: 15
    needs: determine_changes
    if: ${{ needs.determine_changes.outputs.code == 'true' || github.ref == 'refs/heads/main' }}
    runs-on: macos-14
    steps:
      - uses: actions/checkout@v4
      - uses: prefix-dev/setup-pixi@v0.8.3
        with:
          cache: ${{ github.ref == 'refs/heads/main' }}
      - uses: Swatinem/rust-cache@v2
        with:
          workspaces: ". -> target/pixi"
          key: ${{ hashFiles('pixi.lock') }}
          save-if: ${{ github.ref == 'refs/heads/main' }}
      - name: Test pixi
        run: pixi run test-slow
        env:
          PIXI_TEST_R2_ACCESS_KEY_ID: ${{ secrets.PIXI_TEST_R2_ACCESS_KEY_ID }}
          PIXI_TEST_R2_SECRET_ACCESS_KEY: ${{ secrets.PIXI_TEST_R2_SECRET_ACCESS_KEY }}

  cargo-test-macos-x86_64:
    name: "cargo test | macos x86_64"
    timeout-minutes: 30
    needs: determine_changes
    if: ${{ needs.determine_changes.outputs.code == 'true' && github.ref == 'refs/heads/main' }} # Only run on the main branch
    runs-on: macos-13
    steps:
      - uses: actions/checkout@v4
      - uses: prefix-dev/setup-pixi@v0.8.3
        with:
          cache: ${{ github.ref == 'refs/heads/main' }}
      - uses: Swatinem/rust-cache@v2
        with:
          workspaces: ". -> target/pixi"
          key: ${{ hashFiles('pixi.lock') }}
          save-if: ${{ github.ref == 'refs/heads/main' }}
      - name: Test pixi
        run: pixi run test-slow
        env:
          PIXI_TEST_R2_ACCESS_KEY_ID: ${{ secrets.PIXI_TEST_R2_ACCESS_KEY_ID }}
          PIXI_TEST_R2_SECRET_ACCESS_KEY: ${{ secrets.PIXI_TEST_R2_SECRET_ACCESS_KEY }}

  cargo-test-windows:
    name: "cargo test | windows"
    timeout-minutes: 15
    needs: determine_changes
    if: ${{ needs.determine_changes.outputs.code == 'true' || github.ref == 'refs/heads/main' }}
    runs-on: 16core_windows_latest_runner
    steps:
      - uses: actions/checkout@v4
      - name: Create Dev Drive using ReFS
        run: ${{ github.workspace }}/.github/workflows/setup-dev-drive.ps1
      - uses: prefix-dev/setup-pixi@v0.8.3
        with:
          cache: ${{ github.ref == 'refs/heads/main' }}
      - uses: Swatinem/rust-cache@v2
        with:
          workspaces: ". -> target/pixi"
          key: ${{ hashFiles('pixi.lock') }}
          save-if: ${{ github.ref == 'refs/heads/main' }}
      - name: Test pixi
        run: pixi run test-slow
        env:
          PIXI_TEST_R2_ACCESS_KEY_ID: ${{ secrets.PIXI_TEST_R2_ACCESS_KEY_ID }}
          PIXI_TEST_R2_SECRET_ACCESS_KEY: ${{ secrets.PIXI_TEST_R2_SECRET_ACCESS_KEY }}

  #
  # Builds the binary artifacts on different platforms
  #

  build-binary-linux-x86_64:
    needs: determine_changes
    if: ${{ needs.determine_changes.outputs.code == 'true' || github.ref == 'refs/heads/main' }}
    runs-on: 8core_ubuntu_latest_runner
    name: "build binary | linux x86_64"
    steps:
      - uses: actions/checkout@v4
      - uses: rui314/setup-mold@v1
      - name: "Setup musl"
        run: |
          sudo apt-get install musl-tools
          rustup target add x86_64-unknown-linux-musl
      - uses: Swatinem/rust-cache@v2
      - name: "Build"
        run: >
          cargo build
          --locked
          --target x86_64-unknown-linux-musl
          --profile $CARGO_BUILD_PROFILE
          --features self_update
      - name: "Upload binary"
        uses: actions/upload-artifact@v4
        with:
          name: pixi-linux-x86_64-${{ github.sha }}
          path: ./target/x86_64-unknown-linux-musl/${{ env.CARGO_BUILD_PROFILE }}/pixi
          retention-days: 1

  build-binary-macos-aarch64:
    needs: determine_changes
    if: ${{ needs.determine_changes.outputs.code == 'true' || github.ref == 'refs/heads/main' }}
    runs-on: macos-14
    name: "build binary | macos aarch64"
    steps:
      - uses: actions/checkout@v4
      - uses: rui314/setup-mold@v1
      - uses: Swatinem/rust-cache@v2
      - name: "Build"
        run: >
          cargo build
          --locked
          --profile $CARGO_BUILD_PROFILE
          --features self_update
      - name: "Upload binary"
        uses: actions/upload-artifact@v4
        with:
          name: pixi-macos-aarch64-${{ github.sha }}
          path: ./target/${{ env.CARGO_BUILD_PROFILE }}/pixi
          retention-days: 1

  build-binary-macos-x86_64:
    needs: determine_changes
    if: ${{ needs.determine_changes.outputs.code == 'true' && github.ref == 'refs/heads/main' }} # Only run on the main branch
    runs-on: macos-13
    name: "build binary | macos x86_64"
    steps:
      - uses: actions/checkout@v4
      - uses: rui314/setup-mold@v1
      - uses: Swatinem/rust-cache@v2
      - name: "Build"
        run: >
          cargo build
          --locked
          --profile $CARGO_BUILD_PROFILE
          --features self_update
      - name: "Upload binary"
        uses: actions/upload-artifact@v4
        with:
          name: pixi-macos-x86_64-${{ github.sha }}
          path: ./target/${{ env.CARGO_BUILD_PROFILE }}/pixi
          retention-days: 1

  build-binary-windows-x86_64:
    needs: determine_changes
    if: ${{ needs.determine_changes.outputs.code == 'true' || github.ref == 'refs/heads/main' }}
    runs-on: 16core_windows_latest_runner
    name: "build binary | windows x86_64"
    steps:
      - uses: actions/checkout@v4
      - name: Create Dev Drive using ReFS
        run: ${{ github.workspace }}/.github/workflows/setup-dev-drive.ps1
      - name: Copy Git Repo to Dev Drive
        run: |
          Copy-Item -Path "${{ github.workspace }}" -Destination "${{ env.PIXI_WORKSPACE }}" -Recurse
      - uses: Swatinem/rust-cache@v2
        with:
          workspaces: ${{ env.PIXI_WORKSPACE }}
      - name: "Build"
        working-directory: ${{ env.PIXI_WORKSPACE }}
        run: >
          cargo build
          --locked
          --profile $env:CARGO_BUILD_PROFILE
          --features self_update
      - name: "Upload binary"
        uses: actions/upload-artifact@v4
        with:
          name: pixi-windows-x86_64-${{ github.sha }}
          path: ${{ env.PIXI_WORKSPACE }}/target/${{ env.CARGO_BUILD_PROFILE }}/pixi.exe
          retention-days: 1

  build-binary-windows-aarch64:
    needs: determine_changes
    if: ${{ needs.determine_changes.outputs.code == 'true' && github.ref == 'refs/heads/main' }} # Only run on the main branch
    runs-on: 16core_windows_latest_runner
    name: "build binary | windows aarch64"
    steps:
      - uses: actions/checkout@v4
      - name: Create Dev Drive using ReFS
        run: ${{ github.workspace }}/.github/workflows/setup-dev-drive.ps1
      - name: Copy Git Repo to Dev Drive
        run: |
          Copy-Item -Path "${{ github.workspace }}" -Destination "${{ env.PIXI_WORKSPACE }}" -Recurse
      - name: "Install Rust toolchain"
        run: rustup target add aarch64-pc-windows-msvc
      - uses: Swatinem/rust-cache@v2
        with:
          workspaces: ${{ env.PIXI_WORKSPACE }}
      - name: "Build"
        working-directory: ${{ env.PIXI_WORKSPACE }}
        run: >
          cargo build
          --locked
          --target aarch64-pc-windows-msvc
          --profile $env:CARGO_BUILD_PROFILE
          --features self_update
      - name: "Upload binary"
        uses: actions/upload-artifact@v4
        with:
          name: pixi-windows-aarch64-${{ github.sha }}
          path: ${{ env.PIXI_WORKSPACE }}/target/aarch64-pc-windows-msvc/${{ env.CARGO_BUILD_PROFILE }}/pixi.exe
          retention-days: 1

  #
  # Run integration tests on important platforms
  #

  test-pytest-windows-x86_64:
    timeout-minutes: 10
    name: Pytest | windows x86_64
    runs-on: windows-latest
    needs: build-binary-windows-x86_64
    env:
      TARGET_RELEASE: "target/pixi/release"
    steps:
      - uses: actions/checkout@v4
      - name: Create Dev Drive using ReFS
        run: ${{ github.workspace }}/.github/workflows/setup-dev-drive.ps1
      - name: Copy Git Repo to Dev Drive
        run: |
          Copy-Item -Path "${{ github.workspace }}" -Destination "${{ env.PIXI_WORKSPACE }}" -Recurse
          echo "${{ env.PIXI_WORKSPACE }}/${{ env.TARGET_RELEASE }}" | Out-File -Append -Encoding utf8 -FilePath $env:GITHUB_PATH
      - name: Download binary from build
        uses: actions/download-artifact@v4
        with:
          name: pixi-windows-x86_64-${{ github.sha }}
          path: ${{ env.PIXI_WORKSPACE }}/${{ env.TARGET_RELEASE }}
      - name: Verify pixi installation
        working-directory: ${{ env.PIXI_WORKSPACE }}
        run: pixi info

      - name: Run pytests
        working-directory: ${{ env.PIXI_WORKSPACE }}
        run: pixi run --locked test-integration-ci

  test-pytest-macos-aarch64:
    timeout-minutes: 10
    name: Pytest | macos aarch64
    runs-on: macos-14
    needs: build-binary-macos-aarch64
    env:
      TARGET_RELEASE: "${{ github.workspace }}/target/pixi/release"
    steps:
      - uses: actions/checkout@v4
      - name: Download binary from build
        uses: actions/download-artifact@v4
        with:
          name: pixi-macos-aarch64-${{ github.sha }}
          path: ${{ env.TARGET_RELEASE }}
      - name: Setup unix binary, add to github path
        run: |
          chmod a+x ${{ env.TARGET_RELEASE }}/pixi
          echo "${{ env.TARGET_RELEASE }}" >> $GITHUB_PATH
      - name: Verify pixi installation
        run: pixi info

      - name: Run integration tests
        run: pixi run --locked test-integration-ci

  test-pytest-linux-x86_64:
    timeout-minutes: 10
    name: Pytest | linux x86_64
    runs-on: 8core_ubuntu_latest_runner
    needs: build-binary-linux-x86_64
    env:
      TARGET_RELEASE: "${{ github.workspace }}/target/pixi/release"
    steps:
      - uses: actions/checkout@v4
      - name: Download binary from build
        uses: actions/download-artifact@v4
        with:
          name: pixi-linux-x86_64-${{ github.sha }}
          path: ${{ env.TARGET_RELEASE }}
      - name: Setup unix binary, add to github path
        run: |
          chmod a+x ${{ env.TARGET_RELEASE }}/pixi
          echo "${{ env.TARGET_RELEASE }}" >> $GITHUB_PATH
      - name: Verify pixi installation
        run: pixi info

      - name: Run integration tests
        run: pixi run --locked test-integration-ci

  test-integration-windows-x86_64:
    timeout-minutes: 30
    name: Integration tests | windows x86_64
    runs-on: windows-latest
    needs: build-binary-windows-x86_64
    if: ${{ github.ref == 'refs/heads/main' || contains(github.event.pull_request.labels.*.name, 'test:extra_slow') }}
    env:
      TARGET_RELEASE: "target/pixi/release"
    steps:
      - uses: actions/checkout@v4
      - name: Create Dev Drive using ReFS
        run: ${{ github.workspace }}/.github/workflows/setup-dev-drive.ps1
      - name: Copy Git Repo to Dev Drive
        run: |
          Copy-Item -Path "${{ github.workspace }}" -Destination "${{ env.PIXI_WORKSPACE }}" -Recurse
          echo "${{ env.PIXI_WORKSPACE }}/${{ env.TARGET_RELEASE }}" | Out-File -Append -Encoding utf8 -FilePath $env:GITHUB_PATH
      - name: Download binary from build
        uses: actions/download-artifact@v4
        with:
          name: pixi-windows-x86_64-${{ github.sha }}
          path: ${{ env.PIXI_WORKSPACE }}/${{ env.TARGET_RELEASE }}

      - name: Verify pixi installation
        working-directory: ${{ env.PIXI_WORKSPACE }}
        run: pixi info

      - name: Run long running integration tests
        working-directory: ${{ env.PIXI_WORKSPACE }}
        run: pixi run --locked test-integration-extra-slow-ci

      - name: Test examples
        shell: bash
        working-directory: ${{ env.PIXI_WORKSPACE }}
        run: bash tests/scripts/test-examples.sh

  test-integration-macos-aarch64:
    timeout-minutes: 30
    name: Integration tests | macos aarch64
    runs-on: macos-14
    needs: build-binary-macos-aarch64
    if: ${{ github.ref == 'refs/heads/main' || contains(github.event.pull_request.labels.*.name, 'test:extra_slow') }}
    env:
      TARGET_RELEASE: "${{ github.workspace }}/target/pixi/release"
    steps:
      - uses: actions/checkout@v4
      - name: Download binary from build
        uses: actions/download-artifact@v4
        with:
          name: pixi-macos-aarch64-${{ github.sha }}
          path: ${{ env.TARGET_RELEASE }}
      - name: Setup unix binary, add to github path
        run: |
          chmod a+x ${{ env.TARGET_RELEASE }}/pixi
          echo "${{ env.TARGET_RELEASE }}" >> $GITHUB_PATH
      - name: Verify pixi installation
        run: pixi info

      - name: Run long running integration tests
        run: pixi run --locked test-integration-extra-slow-ci

      - name: Run integration tests
        run: pixi run --locked test-integration-ci

      - name: Test examples
        run: bash tests/scripts/test-examples.sh

      - name: Test export
        run: pixi run --locked test-export

  test-integration-linux-x86_64:
    timeout-minutes: 30
    name: Integration tests | linux x86_64
    runs-on: 8core_ubuntu_latest_runner
    needs: build-binary-linux-x86_64
    if: ${{ github.ref == 'refs/heads/main' || contains(github.event.pull_request.labels.*.name, 'test:extra_slow') }}
    env:
      TARGET_RELEASE: "${{ github.workspace }}/target/pixi/release"
    steps:
      - uses: actions/checkout@v4
      - name: Download binary from build
        uses: actions/download-artifact@v4
        with:
          name: pixi-linux-x86_64-${{ github.sha }}
          path: ${{ env.TARGET_RELEASE }}
      - name: Setup unix binary, add to github path
        run: |
          chmod a+x ${{ env.TARGET_RELEASE }}/pixi
          echo "${{ env.TARGET_RELEASE }}" >> $GITHUB_PATH
      - name: Verify pixi installation
        run: pixi info

      - name: Run long running integration tests
        if: ${{ github.ref == 'refs/heads/main' || contains(github.event.pull_request.labels.*.name, 'test:extra_slow') }}
        run: pixi run --locked test-integration-ci -m "extra_slow"

      - name: Run integration tests
        run: pixi run --locked test-integration-ci

      - name: "Test examples"
        run: bash tests/scripts/test-examples.sh

      - name: "Test export"
        run: pixi run --locked test-export

  test-downstream-windows-x86_64:
    timeout-minutes: 30
    name: Downstream tests | windows x86_64
    runs-on: windows-latest
    needs: build-binary-windows-x86_64
    if: ${{ github.ref == 'refs/heads/main' || contains(github.event.pull_request.labels.*.name, 'test:extra_slow') }}
    env:
      TARGET_RELEASE: "target/pixi/release"
    steps:
      - uses: actions/checkout@v4
      - name: Create Dev Drive using ReFS
        run: ${{ github.workspace }}/.github/workflows/setup-dev-drive.ps1
      - name: Copy Git Repo to Dev Drive
        run: |
          Copy-Item -Path "${{ github.workspace }}" -Destination "${{ env.PIXI_WORKSPACE }}" -Recurse
          echo "${{ env.PIXI_WORKSPACE }}/${{ env.TARGET_RELEASE }}" | Out-File -Append -Encoding utf8 -FilePath $env:GITHUB_PATH
      - name: Download binary from build
        uses: actions/download-artifact@v4
        with:
          name: pixi-windows-x86_64-${{ github.sha }}
          path: ${{ env.PIXI_WORKSPACE }}/${{ env.TARGET_RELEASE }}
      - name: Verify pixi installation
        run: pixi info

      - name: Install pixi's pixi project
        working-directory: ${{ env.PIXI_WORKSPACE }}
        run: pixi install -vvv --locked

      - name: Checkout Deltares/Ribasim
        uses: actions/checkout@v4
        with:
          repository: Deltares/Ribasim
          path: ribasim
      - name: Copy Deltares/Ribasim to Dev Drive
        run: Copy-Item -Path "${{ github.workspace }}/ribasim" -Destination "${{ env.PIXI_WORKSPACE }}/ribasim" -Recurse
      - name: Install Deltares/Ribasim
        run: pixi install -vvv --locked
        working-directory: ${{ env.PIXI_WORKSPACE }}/ribasim

      - name: Checkout quantco/polarify
        uses: actions/checkout@v4
        with:
          repository: quantco/polarify
          path: polarify
      - name: Copy quantco/polarify to Dev Drive
        run: Copy-Item -Path "${{ github.workspace }}/polarify" -Destination "${{ env.PIXI_WORKSPACE }}/polarify" -Recurse
      - name: Install quantco/polarify
        run: pixi install -vvv --locked
        working-directory: ${{ env.PIXI_WORKSPACE }}/polarify
      - run: pixi info
        working-directory: ${{ env.PIXI_WORKSPACE }}/polarify
      - run: pixi list
        working-directory: ${{ env.PIXI_WORKSPACE }}/polarify
      - name: Run downstream polarify environment
        run: pixi run --locked echo "Running downstream polarify environment"
        working-directory: ${{ env.PIXI_WORKSPACE }}/polarify

  test-downstream-macos-aarch64:
    timeout-minutes: 15
    name: Downstream tests | macos aarch64
    runs-on: macos-14
    needs: build-binary-macos-aarch64
    if: ${{ github.ref == 'refs/heads/main' || contains(github.event.pull_request.labels.*.name, 'test:extra_slow') }}
    env:
      TARGET_RELEASE: "${{ github.workspace }}/target/pixi/release"
    steps:
      - uses: actions/checkout@v4
      - name: Download binary from build
        uses: actions/download-artifact@v4
        with:
          name: pixi-macos-aarch64-${{ github.sha }}
          path: ${{ env.TARGET_RELEASE }}
      - name: Setup unix binary, add to github path
        run: |
          chmod a+x ${{ env.TARGET_RELEASE }}/pixi
          echo "${{ env.TARGET_RELEASE }}" >> $GITHUB_PATH
      - name: Verify pixi installation
        run: pixi info

      - name: Install pixi
        # Using locked to validate that the lock file is correct
        run: pixi install -vvv --locked

      - name: "Checkout Deltares/Ribasim"
        uses: actions/checkout@v4
        with:
          repository: Deltares/Ribasim
          path: ribasim
      - name: "Install Deltares/Ribasim"
        run: pixi install -vvv --locked
        working-directory: ribasim

      - name: "Checkout quantco/polarify"
        uses: actions/checkout@v4
        with:
          repository: quantco/polarify
          path: polarify
      - name: "Install quantco/polarify"
        run: pixi install -vvv --locked
        working-directory: polarify
      - run: pixi info
      - run: pixi list
      - name: Run downstream polarify environment
        run: pixi run --locked echo "Running downstream polarify environment"

  test-downstream-linux-x86_64:
    timeout-minutes: 15
    name: Downstream tests | linux x86_64
    runs-on: 8core_ubuntu_latest_runner
    needs: build-binary-linux-x86_64
    if: ${{ github.ref == 'refs/heads/main' || contains(github.event.pull_request.labels.*.name, 'test:extra_slow') }}
    env:
      TARGET_RELEASE: "${{ github.workspace }}/target/pixi/release"
    steps:
      - uses: actions/checkout@v4
      - name: Download binary from build
        uses: actions/download-artifact@v4
        with:
          name: pixi-linux-x86_64-${{ github.sha }}
          path: ${{ env.TARGET_RELEASE }}
      - name: Setup unix binary, add to github path
        run: |
          chmod a+x ${{ env.TARGET_RELEASE }}/pixi
          echo "${{ env.TARGET_RELEASE }}" >> $GITHUB_PATH
      - name: Verify pixi installation
        run: pixi info

      - name: Install pixi
        working-directory: ${{ env.PIXI_WORKSPACE }}
        run: pixi install -vvv --locked

      - name: "Checkout nerfstudio-project/nerfstudio"
        uses: actions/checkout@v4
        with:
          repository: nerfstudio-project/nerfstudio
          path: nerfstudio
      - name: "Install nerfstudio-project/nerfstudio"
        # Not using locked as their lockfile is not in sync
        run: pixi install -vvv
        working-directory: nerfstudio

      - name: "Checkout Deltares/Ribasim"
        uses: actions/checkout@v4
        with:
          repository: Deltares/Ribasim
          path: ribasim
      - name: "Install Deltares/Ribasim"
        run: pixi install -vvv --locked
        working-directory: ribasim

      - name: "Checkout quantco/polarify"
        uses: actions/checkout@v4
        with:
          repository: quantco/polarify
          path: polarify
      - name: "Install quantco/polarify"
        run: pixi install -vvv --locked
        working-directory: polarify
      - run: pixi info
      - run: pixi list
      - name: Run downstream polarify environment
        run: pixi run --locked echo "Running downstream polarify environment"
  #
  # Install a number of common wheels on some platforms
  #

  test-common-wheels-linux-x86_64:
    name: Wheel Tests | linux x86_64
    needs:
      - build-binary-linux-x86_64
    uses: ./.github/workflows/test_common_wheels.yml
    with:
      sha: ${{ github.sha }}
      arch: linux-x86_64
      runs-on: 8core_ubuntu_latest_runner

  test-common-wheels-windows-x86_64:
    name: Wheel Tests | windows x86_64
    needs:
      - build-binary-windows-x86_64
    uses: ./.github/workflows/test_common_wheels.yml
    with:
      sha: ${{ github.sha }}
      arch: windows-x86_64
      runs-on: windows-latest

  test-common-wheels-macos-aarch64:
    name: Wheel Tests | macos aarch64
    needs:
      - build-binary-macos-aarch64
    uses: ./.github/workflows/test_common_wheels.yml
    with:
      sha: ${{ github.sha }}
      arch: macos-aarch64
      runs-on: macos-14