all.yml

name: Compile, Test, and Deploy

on:
  pull_request: {}
  push:
    branches:
      - master
  release:
    types: [published]

concurrency:
  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
  # Only cancel superseded PR runs. A push to master can now publish to PyPI and cut a
  # GitHub release, and cancelling that partway through would leave a half-done release.
  cancel-in-progress: ${{ github.event_name == 'pull_request' }}

jobs:
  # Turns a version bump into a release. When a push to master changes __version__ in
  # pedalboard/version.py, this run builds wheels, uploads them to PyPI, and creates the
  # matching GitHub release -- no manual tagging or clicking through the releases UI.
  #
  # Everything stays inside this one workflow run on purpose: a release created with the
  # default GITHUB_TOKEN does NOT trigger new workflow runs, so a separate "create the
  # release" workflow could never kick off the wheel builds here.
  detect-release:
    runs-on: "ubuntu-24.04"
    name: "Detect version bump"
    outputs:
      should-release: ${{ steps.check.outputs.should-release }}
      version: ${{ steps.check.outputs.version }}
    steps:
      - uses: actions/checkout@v4
        with:
          # HEAD~1 is what we compare the version against: on a push it's the previous
          # commit, and on a pull request it's the base branch (HEAD being a merge commit).
          fetch-depth: 2
      - uses: actions/setup-python@v5
        with:
          python-version: "3.12"
      # The logic lives in Python so it can be unit-tested; see tests/test_detect_release.py.
      - name: Check whether this push bumped the version
        id: check
        run: python ./scripts/detect_release.py

  lint-python:
    runs-on: ${{ matrix.os }}
    continue-on-error: true
    strategy:
      matrix:
        python-version: ["3.12"]
        os: ["ubuntu-24.04"]
    name: Lint Python
    steps:
      - name: Set up Python ${{ matrix.python-version }}
        uses: actions/setup-python@v5
        with:
          python-version: ${{ matrix.python-version }}
      - uses: actions/checkout@v4
      - name: Install Ruff
        # Pinned deliberately: Ruff 0.16.0 enables 413 rules by default, up from 59.
        # We don't set `lint.select` in pyproject.toml, so an unpinned upgrade silently
        # widened the rule set and surfaced 90 pre-existing findings. Bumping this pin
        # means adopting (or explicitly selecting away) the newer defaults first.
        # See: https://astral.sh/blog/ruff-v0.16.0
        run: |
          python -m pip install --upgrade pip
          pip install 'ruff==0.15.22'
      - name: Lint Python code
        run: ruff check ${{ github.workspace }}/pedalboard
      - name: Check Python formatting
        run: ruff format --check ${{ github.workspace }}/pedalboard --diff

  type-check-python:
    runs-on: "ubuntu-24.04"
    continue-on-error: true
    name: Type-check Python
    steps:
      - name: Set up Python 3.12
        uses: actions/setup-python@v5
        with:
          python-version: 3.12
      - uses: actions/checkout@v4
        with:
          submodules: recursive
      - name: Install Linux build dependencies
        if: runner.os == 'Linux'
        run: |
          sudo apt-get update \
          && sudo apt-get install -y pkg-config libsndfile1 \
          libx11-dev libxrandr-dev libxinerama-dev \
          libxrender-dev libxcomposite-dev libxcb-xinerama0-dev \
          libxcursor-dev libfreetype6 libfreetype6-dev \
          libasound2-dev
      - name: Install uv
        uses: astral-sh/setup-uv@v5
      - name: uv sync
        run: uv sync --locked --all-extras --dev
      - name: Check Python type hints
        run: uv run pyright ${{ github.workspace }}/pedalboard ${{ github.workspace }}/tests/test_*.py

  lint-cpp:
    runs-on: "ubuntu-24.04"
    continue-on-error: true
    name: Lint C++
    steps:
      - uses: actions/checkout@v4
        # Don't check out submodules, as the action below will look at ALL C++ code!
      - name: Check C++ Formatting
        uses: jidicula/clang-format-action@v4.13.0
        with:
          clang-format-version: 14
          exclude-regex: "vendors/"
          fallback-style: LLVM

  # Build the native module with ccache enabled so we can share object files between builds:
  prime-ubuntu-build-caches:
    runs-on: ${{ matrix.os }}
    continue-on-error: false
    strategy:
      matrix:
        include:
          - {
              os: ubuntu-24.04,
              python-version: "3.12",
              compiler: "gcc",
              cc: "ccache gcc",
              cxx: "ccache g++",
            }
    name: Pre-build on ${{ matrix.os }} with ${{ matrix.compiler }}
    steps:
      - name: Set up Python ${{ matrix.python-version }}
        uses: actions/setup-python@v5
        with:
          python-version: ${{ matrix.python-version }}
      - uses: actions/checkout@v4
        with:
          submodules: recursive
      - name: Install Linux dependencies
        if: runner.os == 'Linux'
        run: |
          sudo apt-get update \
          && sudo apt-get install -y pkg-config libsndfile1 \
          libx11-dev libxrandr-dev libxinerama-dev \
          libxrender-dev libxcomposite-dev libxcb-xinerama0-dev \
          libxcursor-dev libfreetype6 libfreetype6-dev \
          libasound2-dev
      # We depend on ccache features that are only present in 4.8.0 and later, but installing from apt-get gives us v3.
      - name: Install ccache on Linux
        if: runner.os == 'Linux'
        run: |
          mkdir ccache
          curl -L https://github.com/ccache/ccache/releases/download/v4.9.1/ccache-4.9.1-linux-x86_64.tar.xz | tar xvJf - -C ccache
          mv ccache/ccache*/ccache /usr/local/bin/ccache
          chmod +x /usr/local/bin/ccache
      - name: Install ccache on macOS
        if: runner.os == 'macOS'
        run: brew install ccache
      - name: Install test dependencies
        env:
          # on macOS and with Python 3.10: building NumPy from source fails without these options:
          NPY_BLAS_ORDER: ""
          NPY_LAPACK_ORDER: ""
        run: |
          python -m pip install --upgrade pip
          pip install wheel
          pip install -r test-requirements.txt
          # TensorFlow is an optional dependency; if present, we'll run tests with it:
          # There are no environment specifiers to select when TensorFlow binaries are available.
          pip install tensorflow==2.13 || true
      - name: Restore Cached ${{ runner.os }} Objects
        id: cache-objects-restore
        uses: actions/cache/restore@v4
        with:
          enableCrossOsArchive: true
          path: |
            ${{ github.workspace }}/.ccache
            ${{ github.workspace }}/pedalboard/build/lib*
            ${{ github.workspace }}/pedalboard/build/temp${{ github.workspace }}/pedalboard/pedalboard/juce_overrides
            ${{ github.workspace }}/pedalboard/build/temp${{ github.workspace }}/pedalboard/vendors
          key: ${{ matrix.os }}-${{ matrix.compiler }}-ccache
      - name: Build pedalboard locally
        env:
          CCACHE_DIR: ${{ github.workspace }}/.ccache
          CCACHE_BASEDIR: ${{ github.workspace }}
          CCACHE_DEBUGDIR: ${{ github.workspace }}/.ccache_debug
          CCACHE_SLOPPINESS: "pch_defines,include_file_mtime,include_file_ctime,time_macros,locale,random_seed,system_headers"
          CCACHE_COMPILERCHECK: none
          CCACHE_NOINODECACHE: 1
          CCACHE_IGNOREOPTIONS: "-fno-strict-overflow -fwrapv -W* -arch x86_64 arm64 -dynamic -fno-common -g -I/usr/local/opt/*"
          CCACHE_LOGFILE: ${{ github.workspace }}/.ccache_log
          CCACHE_DEBUG: "1"
          USE_PORTABLE_SIMD: "1" # Use portable SIMD to avoid "Illegal instruction" on different runner CPUs
          DISABLE_LTO: "1" # Speeds up un-cacheable link step which doesn't really increase performance in tests anyways
          CC: ${{ matrix.cc }}
          CXX: ${{ matrix.cxx }}
        run: python -m pip install -e .
      - name: Ensure ccache worked
        env:
          CCACHE_DIR: ${{ github.workspace }}/.ccache
        run: |
          ccache --show-stats --verbose
          ccache --zero-stats
        #  cat ${{ github.workspace }}/.ccache_log || true
      # - name: Delete Existing Cache for ${{ runner.os }} Objects
      #   run: gh cache delete --repo ${{ github.repository }} ${{ steps.cache-objects-restore.outputs.cache-primary-key }}
      #   env:
      #     # This token requires the "repo" scope.
      #     GITHUB_TOKEN: ${{ secrets.ACTION_CLEAR_CACHES_TOKEN }}
      - name: Save Cached ${{ runner.os }} Objects
        id: cache-objects-save
        uses: actions/cache/save@v4
        with:
          enableCrossOsArchive: true
          path: |
            ${{ github.workspace }}/.ccache
            ${{ github.workspace }}/pedalboard/build/lib*
            ${{ github.workspace }}/pedalboard/build/temp${{ github.workspace }}/pedalboard/pedalboard/juce_overrides
            ${{ github.workspace }}/pedalboard/build/temp${{ github.workspace }}/pedalboard/vendors
          key: ${{ steps.cache-objects-restore.outputs.cache-primary-key }}

  prime-macos-build-caches:
    runs-on: ${{ matrix.os }}
    continue-on-error: false
    strategy:
      matrix:
        include:
          - {
              os: macos-15-intel,
              python-version: "3.12",
              compiler: "clang",
              cc: "ccache clang",
              cxx: "ccache clang++",
            }
    name: Pre-build on ${{ matrix.os }} with ${{ matrix.compiler }}
    steps:
      - name: Set up Python ${{ matrix.python-version }}
        uses: actions/setup-python@v5
        with:
          python-version: ${{ matrix.python-version }}
      - uses: actions/checkout@v4
        with:
          submodules: recursive
      - name: Install ccache on macOS
        if: runner.os == 'macOS'
        run: brew install ccache
      - name: Install test dependencies
        env:
          # on macOS and with Python 3.10: building NumPy from source fails without these options:
          NPY_BLAS_ORDER: ""
          NPY_LAPACK_ORDER: ""
        run: |
          python -m pip install --upgrade pip
          pip install wheel
          pip install -r test-requirements.txt
      - name: Restore Cached ${{ runner.os }} Objects
        id: cache-objects-restore
        uses: actions/cache/restore@v4
        with:
          enableCrossOsArchive: true
          path: |
            ${{ github.workspace }}/.ccache
            ${{ github.workspace }}/pedalboard/build/lib*
            ${{ github.workspace }}/pedalboard/build/temp${{ github.workspace }}/pedalboard/pedalboard/juce_overrides
            ${{ github.workspace }}/pedalboard/build/temp${{ github.workspace }}/pedalboard/vendors
          key: ${{ matrix.os }}-${{ matrix.compiler }}-ccache
      - name: Build pedalboard locally
        env:
          CCACHE_DIR: ${{ github.workspace }}/.ccache
          CCACHE_BASEDIR: ${{ github.workspace }}
          CCACHE_DEBUGDIR: ${{ github.workspace }}/.ccache_debug
          CCACHE_SLOPPINESS: "pch_defines,include_file_mtime,include_file_ctime,time_macros,locale,random_seed,system_headers"
          CCACHE_COMPILERCHECK: none
          CCACHE_NOINODECACHE: 1
          CCACHE_IGNOREOPTIONS: "-fno-strict-overflow -fwrapv -W* -arch x86_64 arm64 -dynamic -fno-common -g -I/usr/local/opt/*"
          CCACHE_DEBUG: "1"
          # Use the minimum macOS deployment target supported by our version of PyBind:
          MACOSX_DEPLOYMENT_TARGET: "10.14"
          CCACHE_LOGFILE: ${{ github.workspace }}/.ccache_log
          # This build caching is only to speed up tests on CI, so we only care about x86_64 (macos-15-intel runners).
          # Without limiting to a single architecture, ccache can't properly cache mixed Objective-C and C++ builds.
          # Fun fact: this is supported in Python itself! https://github.com/python/cpython/blob/893c9cc/Lib/_osx_support.py#L314-L328
          ARCHFLAGS: -arch x86_64
          DISABLE_LTO: "1" # Speeds up un-cacheable link step which doesn't really increase performance in tests anyways
          CC: ${{ matrix.cc }}
          CXX: ${{ matrix.cxx }}
        run: python -m pip install -e .
      - name: Ensure ccache worked
        env:
          CCACHE_DIR: ${{ github.workspace }}/.ccache
        run: |
          ccache --show-stats --verbose
          ccache --zero-stats
        #  cat ${{ github.workspace }}/.ccache_log || true
        #  ls -lashR ${{ github.workspace }}
      # - name: Delete Existing Cache for ${{ runner.os }} Objects
      #   run: gh cache delete --repo ${{ github.repository }} ${{ steps.cache-objects-restore.outputs.cache-primary-key }}
      #   env:
      #     # This token requires the "repo" scope.
      #     GITHUB_TOKEN: ${{ secrets.ACTION_CLEAR_CACHES_TOKEN }}
      - name: Save Cached ${{ runner.os }} Objects
        id: cache-objects-save
        uses: actions/cache/save@v4
        with:
          enableCrossOsArchive: true
          path: |
            ${{ github.workspace }}/.ccache
            ${{ github.workspace }}/pedalboard/build/lib*
            ${{ github.workspace }}/pedalboard/build/temp${{ github.workspace }}/pedalboard/pedalboard/juce_overrides
            ${{ github.workspace }}/pedalboard/build/temp${{ github.workspace }}/pedalboard/vendors
          key: ${{ steps.cache-objects-restore.outputs.cache-primary-key }}

  # Build the native module with ccache enabled so we can share object files between builds:
  prime-asan-build-caches:
    runs-on: ${{ matrix.os }}
    continue-on-error: false
    strategy:
      matrix:
        include:
          - {
              os: ubuntu-24.04,
              python-version: "3.12",
              compiler: "clang",
              cc: "ccache clang",
              cxx: "ccache clang++",
            }
    name: Pre-build on ${{ matrix.os }} with ${{ matrix.compiler }}
    steps:
      - name: Set up Python ${{ matrix.python-version }}
        uses: actions/setup-python@v5
        with:
          python-version: ${{ matrix.python-version }}
      - uses: actions/checkout@v4
        with:
          submodules: recursive
      - name: Install Linux dependencies
        if: runner.os == 'Linux'
        run: |
          sudo apt-get update \
          && sudo apt-get install -y pkg-config libsndfile1 \
          libx11-dev libxrandr-dev libxinerama-dev \
          libxrender-dev libxcomposite-dev libxcb-xinerama0-dev \
          libxcursor-dev libfreetype6 libfreetype6-dev \
          libasound2-dev
      # We depend on ccache features that are only present in 4.8.0 and later, but installing from apt-get gives us v3.
      - name: Install ccache on Linux
        if: runner.os == 'Linux'
        run: |
          mkdir ccache
          curl -L https://github.com/ccache/ccache/releases/download/v4.9.1/ccache-4.9.1-linux-x86_64.tar.xz | tar xvJf - -C ccache
          mv ccache/ccache*/ccache /usr/local/bin/ccache
          chmod +x /usr/local/bin/ccache
      - name: Install ccache on macOS
        if: runner.os == 'macOS'
        run: brew install ccache
      - name: Install test dependencies
        env:
          # on macOS and with Python 3.10: building NumPy from source fails without these options:
          NPY_BLAS_ORDER: ""
          NPY_LAPACK_ORDER: ""
        run: |
          python -m pip install --upgrade pip
          pip install wheel
          pip install -r test-requirements.txt
          # TensorFlow is an optional dependency; if present, we'll run tests with it:
          # There are no environment specifiers to select when TensorFlow binaries are available.
          pip install tensorflow==2.13 || true
      - name: Restore Cached ${{ runner.os }} Objects
        id: cache-objects-restore
        uses: actions/cache/restore@v4
        with:
          enableCrossOsArchive: true
          path: |
            ${{ github.workspace }}/.ccache
            ${{ github.workspace }}/pedalboard/build/lib*
            ${{ github.workspace }}/pedalboard/build/temp${{ github.workspace }}/pedalboard/pedalboard/juce_overrides
            ${{ github.workspace }}/pedalboard/build/temp${{ github.workspace }}/pedalboard/vendors
          key: ${{ matrix.os }}-${{ matrix.compiler }}-ccache
      - name: Build pedalboard locally
        env:
          CCACHE_DIR: ${{ github.workspace }}/.ccache
          CCACHE_BASEDIR: ${{ github.workspace }}
          CCACHE_DEBUGDIR: ${{ github.workspace }}/.ccache_debug
          CCACHE_SLOPPINESS: "pch_defines,include_file_mtime,include_file_ctime,time_macros,locale,random_seed,system_headers"
          CCACHE_COMPILERCHECK: none
          CCACHE_NOINODECACHE: 1
          CCACHE_IGNOREOPTIONS: "-fno-strict-overflow -fwrapv -W* -arch x86_64 arm64 -dynamic -fno-common -g -I/usr/local/opt/*"
          CCACHE_LOGFILE: ${{ github.workspace }}/.ccache_log
          USE_ASAN: "1"
          USE_PORTABLE_SIMD: "1" # Use portable SIMD to avoid "Illegal instruction" on different runner CPUs
          DISABLE_LTO: "1" # Speeds up un-cacheable link step which doesn't really increase performance in tests anyways
          CC: ${{ matrix.cc }}
          CXX: ${{ matrix.cxx }}
        run: python -m pip install -e .
      - name: Ensure ccache worked
        env:
          CCACHE_DIR: ${{ github.workspace }}/.ccache
        run: |
          ccache --show-stats --verbose
          ccache --zero-stats
        #  cat ${{ github.workspace }}/.ccache_log || true
        #  ls -lashR ${{ github.workspace }}
      # - name: Delete Existing Cache for ${{ runner.os }} Objects
      #   run: gh cache delete --repo ${{ github.repository }} ${{ steps.cache-objects-restore.outputs.cache-primary-key }}
      #   env:
      #     # This token requires the "repo" scope.
      #     GITHUB_TOKEN: ${{ secrets.ACTION_CLEAR_CACHES_TOKEN }}
      - name: Save Cached ${{ runner.os }} Objects
        id: cache-objects-save
        uses: actions/cache/save@v4
        with:
          enableCrossOsArchive: true
          path: |
            ${{ github.workspace }}/.ccache
            ${{ github.workspace }}/pedalboard/build/lib*
            ${{ github.workspace }}/pedalboard/build/temp${{ github.workspace }}/pedalboard/pedalboard/juce_overrides
            ${{ github.workspace }}/pedalboard/build/temp${{ github.workspace }}/pedalboard/vendors
          key: ${{ steps.cache-objects-restore.outputs.cache-primary-key }}

  # This initial job catches obvious failures faster by running tests in parallel on just Ubuntu.
  run-tests-in-parallel:
    runs-on: ${{ matrix.os }}
    continue-on-error: false
    needs:
      - prime-ubuntu-build-caches
    strategy:
      matrix:
        os: ["ubuntu-24.04"]
        python-version: ["3.12"]
        compiler: ["gcc"]
        cc: ["ccache gcc"]
        cxx: ["ccache g++"]
        runner_index: ["1", "2", "3", "4", "5", "6", "7", "8"]
        runner_total: ["8"]
    name: Test ${{ matrix.runner_index }} / ${{ matrix.runner_total }} with Python ${{ matrix.python-version }} on ${{ matrix.os }}
    steps:
      - name: Set up Python ${{ matrix.python-version }}
        uses: actions/setup-python@v5
        with:
          python-version: ${{ matrix.python-version }}
      - uses: actions/checkout@v4
        with:
          submodules: recursive
      - name: Install Linux dependencies
        if: runner.os == 'Linux'
        run: |
          sudo apt-get update \
          && sudo apt-get install -y pkg-config libsndfile1 \
          libx11-dev libxrandr-dev libxinerama-dev \
          libxrender-dev libxcomposite-dev libxcb-xinerama0-dev \
          libxcursor-dev libfreetype6 libfreetype6-dev \
          libasound2-dev
      # We depend on ccache features that are only present in 4.8.0 and later, but installing from apt-get gives us v3.
      - name: Install ccache on Linux
        if: runner.os == 'Linux'
        run: |
          mkdir ccache
          curl -L https://github.com/ccache/ccache/releases/download/v4.9.1/ccache-4.9.1-linux-x86_64.tar.xz | tar xvJf - -C ccache
          mv ccache/ccache*/ccache /usr/local/bin/ccache
          chmod +x /usr/local/bin/ccache
      - name: Install test dependencies
        env:
          # on macOS and with Python 3.10: building NumPy from source fails without these options:
          NPY_BLAS_ORDER: ""
          NPY_LAPACK_ORDER: ""
        run: |
          python -m pip install --upgrade pip
          pip install wheel
          pip install -r test-requirements.txt
          # TensorFlow is an optional dependency; if present, we'll run tests with it:
          # There are no environment specifiers to select when TensorFlow binaries are available.
          pip install tensorflow==2.13 || true
      - name: Restore Cached ${{ runner.os }} Objects
        id: cache-objects-restore
        uses: actions/cache/restore@v4
        with:
          enableCrossOsArchive: true
          path: |
            ${{ github.workspace }}/.ccache
            ${{ github.workspace }}/pedalboard/build/lib*
            ${{ github.workspace }}/pedalboard/build/temp${{ github.workspace }}/pedalboard/pedalboard/juce_overrides
            ${{ github.workspace }}/pedalboard/build/temp${{ github.workspace }}/pedalboard/vendors
          key: ${{ matrix.os }}-${{ matrix.compiler }}-ccache
      - name: Print Restored ${{ runner.os }} Objects
        run: ls -lashR ${{ github.workspace }}
      # Without this, distutils will recompile the extension even though we already have the .so built:
      - name: Touch Restored ${{ runner.os }} Objects to Prevent Cache Miss
        if: runner.os == 'Linux' || runner.os == 'macOS'
        run: |
          find ${{ github.workspace }} -name '*.so' -exec touch {} \; || true
          find ${{ github.workspace }} -name '*.o' -exec touch {} \; || true
          ls -lR ${{ github.workspace }}/pedalboard
      - name: Build pedalboard locally
        run: python -m pip install -e .
        env:
          CCACHE_DIR: ${{ github.workspace }}/.ccache
          CCACHE_BASEDIR: ${{ github.workspace }}
          CCACHE_DEBUGDIR: ${{ github.workspace }}/.ccache_debug
          CCACHE_SLOPPINESS: "pch_defines,include_file_mtime,include_file_ctime,time_macros,locale,random_seed,system_headers"
          CCACHE_COMPILERCHECK: none
          CCACHE_NOINODECACHE: 1
          CCACHE_IGNOREOPTIONS: "-fno-strict-overflow -fwrapv -W* -arch x86_64 arm64 -dynamic -fno-common -g -I/usr/local/opt/*"
          CCACHE_LOGFILE: ${{ github.workspace }}/.ccache_log
          USE_PORTABLE_SIMD: "1" # Use portable SIMD to avoid "Illegal instruction" on different runner CPUs
          DISABLE_LTO: "1" # Speeds up un-cacheable link step which doesn't really increase performance in tests anyways
          CC: ${{ matrix.cc }}
          CXX: ${{ matrix.cxx }}
      - name: Ensure ccache worked
        env:
          CCACHE_DIR: ${{ github.workspace }}/.ccache
        run: |
          ccache --show-stats --verbose
          ccache --zero-stats
        #  cat ${{ github.workspace }}/.ccache_log || true
        #  ls -lashR ${{ github.workspace }}
      - name: Install VSTs for testing
        env:
          GCS_ASSET_BUCKET_NAME: ${{ secrets.GCS_ASSET_BUCKET_NAME }}
          GCS_READER_SERVICE_ACCOUNT_KEY: ${{ secrets.GCS_READER_SERVICE_ACCOUNT_KEY }}
        run: |
          # Inline install here on purpose, as this is only required for test _setup_ and not running
          pip install google-cloud-storage
          python ./tests/download_test_plugins.py
      - name: Setup audio device for testing
        if: runner.os == 'Linux'
        run: |
          sudo apt-get install -y pulseaudio
          pulseaudio --start
          pactl load-module module-null-sink sink_name=test
          pactl set-default-sink test
      - name: Run tests
        env:
          TEST_WORKER_INDEX: ${{ matrix.runner_index }}
          NUM_TEST_WORKERS: ${{ matrix.runner_total }}
        run: pytest --maxfail=1 --durations=10

  run-tests:
    runs-on: ${{ matrix.os }}
    continue-on-error: false
    needs:
      - prime-ubuntu-build-caches
      - prime-macos-build-caches
    env:
      MINIMUM_COVERAGE_PERCENTAGE: 80
    strategy:
      matrix:
        include:
          - {
              os: macos-15-intel,
              python-version: "3.10",
              compiler: "clang",
              cc: "ccache clang",
              cxx: "ccache clang++",
            }
          - {
              os: macos-15-intel,
              python-version: "3.11",
              compiler: "clang",
              cc: "ccache clang",
              cxx: "ccache clang++",
            }
          - {
              os: macos-15-intel,
              python-version: "3.12",
              compiler: "clang",
              cc: "ccache clang",
              cxx: "ccache clang++",
            }
          - {
              os: macos-15-intel,
              python-version: "3.13",
              compiler: "clang",
              cc: "ccache clang",
              cxx: "ccache clang++",
            }
          - {
              os: macos-15-intel,
              python-version: "3.14",
              compiler: "clang",
              cc: "ccache clang",
              cxx: "ccache clang++",
            }
          - {
              os: macos-15-intel,
              python-version: "3.15",
              compiler: "clang",
              cc: "ccache clang",
              cxx: "ccache clang++",
            }
          - {
              os: ubuntu-24.04,
              python-version: "3.10",
              compiler: "gcc",
              cc: "ccache gcc",
              cxx: "ccache g++",
            }
          - {
              os: ubuntu-24.04,
              python-version: "3.11",
              compiler: "gcc",
              cc: "ccache gcc",
              cxx: "ccache g++",
            }
          - {
              os: ubuntu-24.04,
              python-version: "3.12",
              compiler: "gcc",
              cc: "ccache gcc",
              cxx: "ccache g++",
            }
          - {
              os: ubuntu-24.04,
              python-version: "3.13",
              compiler: "gcc",
              cc: "ccache gcc",
              cxx: "ccache g++",
            }
          - {
              os: ubuntu-24.04,
              python-version: "3.14",
              compiler: "gcc",
              cc: "ccache gcc",
              cxx: "ccache g++",
            }
          - {
              os: ubuntu-24.04,
              python-version: "3.15",
              compiler: "gcc",
              cc: "ccache gcc",
              cxx: "ccache g++",
            }
          - {
              os: windows-latest,
              python-version: "3.10",
              compiler: "msvc",
              cc: "msvc",
              cxx: "msvc",
            }
          - {
              os: windows-latest,
              python-version: "3.11",
              compiler: "msvc",
              cc: "msvc",
              cxx: "msvc",
            }
          - {
              os: windows-latest,
              python-version: "3.12",
              compiler: "msvc",
              cc: "msvc",
              cxx: "msvc",
            }
          - {
              os: windows-latest,
              python-version: "3.13",
              compiler: "msvc",
              cc: "msvc",
              cxx: "msvc",
            }
          - {
              os: windows-latest,
              python-version: "3.14",
              compiler: "msvc",
              cc: "msvc",
              cxx: "msvc",
            }
          - {
              os: windows-latest,
              python-version: "3.15",
              compiler: "msvc",
              cc: "msvc",
              cxx: "msvc",
            }
    name: Test with Python ${{ matrix.python-version }} on ${{ matrix.os }}
    steps:
      - name: Set up Python ${{ matrix.python-version }}
        uses: actions/setup-python@v5
        with:
          python-version: ${{ matrix.python-version }}
          # Required while the newest Python in the matrix is still a release candidate:
          allow-prereleases: true
      - uses: actions/checkout@v4
        with:
          submodules: recursive
      - name: Install Linux dependencies
        if: runner.os == 'Linux'
        run: |
          sudo apt-get update \
          && sudo apt-get install -y pkg-config libsndfile1 \
          libx11-dev libxrandr-dev libxinerama-dev \
          libxrender-dev libxcomposite-dev libxcb-xinerama0-dev \
          libxcursor-dev libfreetype6 libfreetype6-dev \
          libasound2-dev
      # We depend on ccache features that are only present in 4.8.0 and later, but installing from apt-get gives us v3.
      - name: Install ccache on Linux
        if: runner.os == 'Linux'
        run: |
          mkdir ccache
          curl -L https://github.com/ccache/ccache/releases/download/v4.9.1/ccache-4.9.1-linux-x86_64.tar.xz | tar xvJf - -C ccache
          mv ccache/ccache*/ccache /usr/local/bin/ccache
          chmod +x /usr/local/bin/ccache
      - name: Install ccache on macOS
        if: runner.os == 'macOS'
        run: brew install ccache
      - name: Install test dependencies
        env:
          # on macOS and with Python 3.10: building NumPy from source fails without these options:
          NPY_BLAS_ORDER: ""
          NPY_LAPACK_ORDER: ""
        run: |
          python -m pip install --upgrade pip
          pip install wheel
          pip install -r test-requirements.txt
          pip install pybind11 'scikit-build-core[pyproject]'
          # TensorFlow is an optional dependency; if present, we'll run tests with it:
          # There are no environment specifiers to select when TensorFlow binaries are available.
          pip install tensorflow==2.13 || true
      - name: Install JQ for coverage badge on Linux
        run: sudo apt-get install -y jq
        if: runner.os == 'Linux'
      - name: Install JQ for coverage badge on macOS
        run: brew install jq
        if: runner.os == 'macOS'
      - name: Install JQ for coverage badge on Windows
        if: runner.os == 'Windows'
        uses: crazy-max/ghaction-chocolatey@v2
        with:
          args: install jq
      - name: Restore Cached ${{ runner.os }} Objects
        id: cache-objects-restore
        uses: actions/cache/restore@v4
        with:
          enableCrossOsArchive: true
          path: |
            ${{ github.workspace }}/.ccache
            ${{ github.workspace }}/pedalboard/build/lib*
            ${{ github.workspace }}/pedalboard/build/temp${{ github.workspace }}/pedalboard/pedalboard/juce_overrides
            ${{ github.workspace }}/pedalboard/build/temp${{ github.workspace }}/pedalboard/vendors
          key: ${{ matrix.os }}-${{ matrix.compiler }}-ccache
      # Without this, distutils will recompile the extension even though we already have the shared object built:
      - name: Touch Restored ${{ runner.os }} Objects to Prevent Cache Miss
        if: runner.os == 'Linux' || runner.os == 'macOS'
        run: |
          find ${{ github.workspace }} -name '*.so' -exec touch {} \; || true
          find ${{ github.workspace }} -name '*.o' -exec touch {} \; || true
          ls -lR ${{ github.workspace }}/pedalboard
      - name: Build pedalboard locally
        run: python -m pip install -ve .
        env:
          CCACHE_DIR: ${{ github.workspace }}/.ccache
          CCACHE_BASEDIR: ${{ github.workspace }}
          CCACHE_DEBUGDIR: ${{ github.workspace }}/.ccache_debug
          CCACHE_SLOPPINESS: "pch_defines,include_file_mtime,include_file_ctime,time_macros,locale,random_seed,system_headers"
          CCACHE_COMPILERCHECK: none
          CCACHE_NOINODECACHE: 1
          CCACHE_IGNOREOPTIONS: "-fno-strict-overflow -fwrapv -W* -arch x86_64 arm64 -dynamic -fno-common -g -I/usr/local/opt/*"
          CCACHE_LOGFILE: ${{ github.workspace }}/.ccache_log
          CCACHE_DEBUG: "1"
          USE_PORTABLE_SIMD: "1" # Use portable SIMD to avoid "Illegal instruction" on different runner CPUs
          # Use the minimum macOS deployment target supported by our version of PyBind:
          MACOSX_DEPLOYMENT_TARGET: "10.14"
          # This build caching is only to speed up tests on CI, so we only care about x86_64 (macos-15-intel runners).
          # Without limiting to a single architecture, ccache can't properly cache mixed Objective-C and C++ builds.
          # Fun fact: this is supported in Python itself! https://github.com/python/cpython/blob/893c9cc/Lib/_osx_support.py#L314-L328
          ARCHFLAGS: -arch x86_64
          DISABLE_LTO: "1" # Speeds up un-cacheable link step which doesn't really increase performance in tests anyways
          CC: ${{ matrix.cc }}
          CXX: ${{ matrix.cxx }}
      - name: Ensure ccache worked
        if: runner.os == 'Linux' || runner.os == 'macOS'
        env:
          CCACHE_DIR: ${{ github.workspace }}/.ccache
        run: |
          ccache --show-stats --verbose
          ccache --zero-stats
        #  cat ${{ github.workspace }}/.ccache_log || true
      - name: Install VSTs for testing
        env:
          GCS_ASSET_BUCKET_NAME: ${{ secrets.GCS_ASSET_BUCKET_NAME }}
          GCS_READER_SERVICE_ACCOUNT_KEY: ${{ secrets.GCS_READER_SERVICE_ACCOUNT_KEY }}
        run: |
          # Inline install here on purpose, as this is only required for test _setup_ and not running
          pip install google-cloud-storage
          python ./tests/download_test_plugins.py
      - name: Run tests
        if: matrix.os != 'ubuntu-24.04' || matrix.python-version != '3.10'
        run: pytest --maxfail=4 --cov-report term --cov-fail-under=${{ env.MINIMUM_COVERAGE_PERCENTAGE }} --cov=pedalboard --durations=100
      - name: Run tests with coverage reporting
        if: matrix.os == 'ubuntu-24.04' && matrix.python-version == '3.10'
        run: |
          pytest --maxfail=4 --cov-report term --cov-fail-under=${{ env.MINIMUM_COVERAGE_PERCENTAGE }} --cov=pedalboard \
          && coverage json --fail-under=${{ env.MINIMUM_COVERAGE_PERCENTAGE }} \
          && jq -r 'def roundit: .*100.0 + 0.5|floor/100.0; .totals.percent_covered | round | "COVERAGE_PERCENTAGE=" + (. | tostring) + "%" ' coverage.json >> $GITHUB_ENV \
          && jq -r 'if .totals.percent_covered > ${{ env.MINIMUM_COVERAGE_PERCENTAGE }} then "COVERAGE_COLOR=green" else "COVERAGE_COLOR=red" end' coverage.json >> $GITHUB_ENV
      - name: Create coverage badge
        uses: schneegans/dynamic-badges-action@v1.1.0
        if: matrix.os == 'ubuntu-24.04' && matrix.python-version == '3.10' && github.event_name == 'release' && github.event.action == 'published'
        with:
          auth: ${{ secrets.COVERAGE_GIST_SECRET }}
          gistID: 8736467e9952991ef44a67915ee7c762
          filename: coverage.json
          label: Test Coverage
          message: ${{ env.COVERAGE_PERCENTAGE }}
          color: ${{ env.COVERAGE_COLOR }}

  run-tests-with-address-sanitizer:
    runs-on: ${{ matrix.os }}
    needs: [prime-asan-build-caches]
    strategy:
      matrix:
        python-version: ["3.10", "3.11", "3.12", "3.13", "3.14", "3.15"]
        os: ["ubuntu-24.04"]
    name: Test with Python ${{ matrix.python-version }} + Address Sanitizer
    steps:
      - name: Set up Python ${{ matrix.python-version }}
        uses: actions/setup-python@v5
        with:
          python-version: ${{ matrix.python-version }}
          # Required while the newest Python in the matrix is still a release candidate:
          allow-prereleases: true
      - uses: actions/checkout@v4
        with:
          submodules: recursive
      - name: Install Linux dependencies
        if: runner.os == 'Linux'
        run: |
          sudo apt-get update \
          && sudo apt-get install -y pkg-config libsndfile1 \
          libx11-dev libxrandr-dev libxinerama-dev \
          libxrender-dev libxcomposite-dev libxcb-xinerama0-dev \
          libxcursor-dev libfreetype6 libfreetype6-dev \
          libasound2-dev
      # We depend on ccache features that are only present in 4.8.0 and later, but installing from apt-get gives us v3.
      - name: Install ccache on Linux
        if: runner.os == 'Linux'
        run: |
          mkdir ccache
          curl -L https://github.com/ccache/ccache/releases/download/v4.9.1/ccache-4.9.1-linux-x86_64.tar.xz | tar xvJf - -C ccache
          mv ccache/ccache*/ccache /usr/local/bin/ccache
          chmod +x /usr/local/bin/ccache
      - name: Install test dependencies
        run: |
          python -m pip install --upgrade pip
          pip install wheel
          pip install -r test-requirements.txt
          # TensorFlow is an optional dependency; if present, we'll run tests with it:
          # There are no environment specifiers to select when TensorFlow binaries are available.
          pip install tensorflow==2.13 || true
      - name: Restore Cached ${{ runner.os }} Objects
        id: cache-objects-restore
        uses: actions/cache/restore@v4
        with:
          enableCrossOsArchive: true
          path: |
            ${{ github.workspace }}/.ccache
            ${{ github.workspace }}/pedalboard/build/lib*
            ${{ github.workspace }}/pedalboard/build/temp${{ github.workspace }}/pedalboard/pedalboard/juce_overrides
            ${{ github.workspace }}/pedalboard/build/temp${{ github.workspace }}/pedalboard/vendors
          key: ${{ matrix.os }}-clang-ccache
      - name: Build pedalboard locally
        env:
          DEBUG: "0"
          USE_ASAN: "1"
          USE_PORTABLE_SIMD: "1" # Use portable SIMD to avoid "Illegal instruction" on different runner CPUs
          CCACHE_DIR: ${{ github.workspace }}/.ccache
          CCACHE_BASEDIR: ${{ github.workspace }}
          CCACHE_DEBUGDIR: ${{ github.workspace }}/.ccache_debug
          CCACHE_SLOPPINESS: "pch_defines,include_file_mtime,include_file_ctime,time_macros,locale,random_seed,system_headers"
          CCACHE_COMPILERCHECK: none
          CCACHE_NOINODECACHE: 1
          CCACHE_IGNOREOPTIONS: "-fno-strict-overflow -fwrapv -W* -arch x86_64 arm64 -dynamic -fno-common -g -I/usr/local/opt/*"
          CCACHE_LOGFILE: ${{ github.workspace }}/.ccache_log
          CCACHE_DEBUG: "1"
          DISABLE_LTO: "1" # Speeds up un-cacheable link step which doesn't really increase performance in tests anyways
          CC: ccache clang
          CXX: ccache clang++
        run: python -m pip install -e .
      - name: Ensure ccache worked
        env:
          CCACHE_DIR: ${{ github.workspace }}/.ccache
        run: |
          ccache --show-stats --verbose
          ccache --zero-stats
        #  cat ${{ github.workspace }}/.ccache_log || true
      - name: Run tests with ASan loaded
        # pytest can exit before all Python objects have been destroyed,
        # so we tell ASan to ignore leaks.
        run: |
          ASAN_OPTIONS=detect_leaks=0 \
          LD_PRELOAD=$(clang -print-file-name=libclang_rt.asan-x86_64.so) \
          pytest --maxfail=4

  build-wheels:
    needs: [lint-python, lint-cpp, detect-release]
    runs-on: ${{ matrix.os }}
    continue-on-error: false
    # Built on three occasions: a version bump landing on master (the automated release
    # path), a manually-published GitHub release (the older manual path, still supported),
    # or a PR labelled "Also Test Wheels".
    if: >-
      needs.detect-release.outputs.should-release == 'true'
      || (github.event_name == 'release' && github.event.action == 'published')
      || contains(github.event.pull_request.labels.*.name, 'Also Test Wheels')
    strategy:
      matrix:
        include:
          - { os: macos-15-intel, build: cp310-macosx_x86_64 }
          - { os: macos-15-intel, build: cp311-macosx_x86_64 }
          - { os: macos-15-intel, build: cp312-macosx_x86_64 }
          - { os: macos-15-intel, build: cp313-macosx_x86_64 }
          # Universal wheels are rarely used; only support them for Python 3.12:
          - { os: macos-15-intel, build: cp312-macosx_universal2 }
          - { os: macos-15-intel, build: cp310-macosx_arm64 }
          - { os: macos-15-intel, build: cp311-macosx_arm64 }
          - { os: macos-15-intel, build: cp312-macosx_arm64 }
          - { os: macos-15-intel, build: cp313-macosx_arm64 }
          - { os: macos-15-intel, build: cp314-macosx_arm64 }
          - { os: macos-15-intel, build: cp314t-macosx_arm64 }
          - { os: macos-15-intel, build: cp315-macosx_arm64 }
          - { os: macos-15-intel, build: cp315t-macosx_arm64 }
          # - { os: macos-15-intel, build: pp38-macosx_x86_64 }
          # - { os: macos-15-intel, build: pp39-macosx_x86_64 }
          - { os: windows-latest, build: cp310-win_amd64 }
          - { os: windows-latest, build: cp311-win_amd64 }
          - { os: windows-latest, build: cp312-win_amd64 }
          - { os: windows-latest, build: cp313-win_amd64 }
          - { os: windows-latest, build: cp314-win_amd64 }
          - { os: windows-latest, build: cp315-win_amd64 }
          # - { os: windows-latest, build: cp312-win32 }
          - { os: "ubuntu-24.04", build: cp310-manylinux_x86_64 }
          - { os: "ubuntu-24.04-arm", build: cp310-manylinux_aarch64 }
          - { os: "ubuntu-24.04", build: cp310-musllinux_x86_64 }
          - { os: "ubuntu-24.04-arm", build: cp310-musllinux_aarch64 }
          - { os: "ubuntu-24.04", build: cp311-manylinux_x86_64 }
          - { os: "ubuntu-24.04-arm", build: cp311-manylinux_aarch64 }
          # - { os: 'ubuntu-24.04', build: cp311-musllinux_x86_64 }
          # - { os: 'ubuntu-24.04', build: cp311-musllinux_aarch64 }
          - { os: "ubuntu-24.04", build: cp312-manylinux_x86_64 }
          - { os: "ubuntu-24.04-arm", build: cp312-manylinux_aarch64 }
          - { os: "ubuntu-24.04", build: cp312-musllinux_x86_64 }
          - { os: "ubuntu-24.04-arm", build: cp312-musllinux_aarch64 }
          - { os: "ubuntu-24.04", build: cp313-manylinux_x86_64 }
          - { os: "ubuntu-24.04-arm", build: cp313-manylinux_aarch64 }
          # - { os: 'ubuntu-24.04', build: cp313-musllinux_x86_64 }
          # - { os: 'ubuntu-24.04', build: cp313-musllinux_aarch64 }
          - { os: "ubuntu-24.04", build: cp314-manylinux_x86_64 }
          - { os: "ubuntu-24.04-arm", build: cp314-manylinux_aarch64 }
          - { os: "ubuntu-24.04-arm", build: cp314t-manylinux_aarch64 }
          - { os: "ubuntu-24.04", build: cp315-manylinux_x86_64 }
          - { os: "ubuntu-24.04-arm", build: cp315-manylinux_aarch64 }
          - { os: "ubuntu-24.04-arm", build: cp315t-manylinux_aarch64 }
    name: Build wheel for ${{ matrix.build }}
    steps:
      - uses: actions/checkout@v4
        with:
          submodules: recursive
      # Used to host cibuildwheel, so version doesn't really matter
      - uses: actions/setup-python@v5
        with:
          python-version: "3.13"
      - name: Install cibuildwheel
        # cibuildwheel 4.2.0 is the first release to build CPython 3.15 wheels by
        # default (using 3.15.0rc1, which is ABI-compatible with the final release).
        run: python -m pip install 'cibuildwheel>=4.2,<5'
      - name: Build wheels
        run: python -m cibuildwheel --output-dir wheelhouse
        env:
          CIBW_BUILD: ${{ matrix.build }}
          CIBW_TEST_COMMAND: "python -c \"import pedalboard; print(pedalboard.__version__)\""
          CIBW_TEST_REQUIRES: ""
          # on macOS and with Python 3.10: building NumPy from source fails without these options:
          CIBW_ENVIRONMENT: NPY_BLAS_ORDER="" NPY_LAPACK_ORDER="" CIBW_BUILD="${{ matrix.build }}"
          # Use the minimum macOS deployment target supported by our version of PyBind:
          MACOSX_DEPLOYMENT_TARGET: "10.14"
      - name: Ensure wheels have required files
        if: runner.os != 'Windows'
        run: |
          for wheel in ./wheelhouse/*.whl; do
            # Print the contents of the wheel for debugging:
            unzip -l "$wheel"

            # Check that the wheel has py.typed in it:
            unzip -l "$wheel" | grep 'pedalboard_native/py.typed'
          done
      - uses: actions/upload-artifact@v4
        with:
          name: wheel-${{ matrix.build }}
          path: ./wheelhouse/*.whl

  merge:
    runs-on: ubuntu-latest
    needs: build-wheels
    steps:
      - name: Merge Artifacts
        uses: actions/upload-artifact/merge@v4
        with:
          name: wheels
          pattern: wheel-*

  upload-pypi:
    needs: [merge, run-tests-with-address-sanitizer, run-tests, detect-release]
    runs-on: "ubuntu-24.04"
    name: "Upload wheels to PyPI"
    # The last gate before anything irreversible happens. Adding a required reviewer to
    # the "PyPI Deployment" environment (Settings -> Environments) makes this job pause
    # for a human approval; without one it runs straight through, as it does today.
    # Moving PYPI_DEPLOY_TOKEN into that environment also stops any other job -- or any
    # future workflow change -- from being able to publish.
    environment:
      name: PyPI Deployment
      url: https://pypi.org/project/pedalboard/
    if: >-
      needs.detect-release.outputs.should-release == 'true'
      || (github.event_name == 'release' && github.event.action == 'published')
    steps:
      - uses: actions/download-artifact@v4
        with:
          name: wheels
          path: dist
      - uses: pypa/gh-action-pypi-publish@v1.4.2
        with:
          user: __token__
          password: ${{ secrets.PYPI_DEPLOY_TOKEN }}

  # Runs only on the automated path, after PyPI has accepted the wheels: tags the commit
  # and creates the GitHub release. On the manual path the release already exists.
  create-github-release:
    needs: [upload-pypi, detect-release]
    runs-on: "ubuntu-24.04"
    name: "Create GitHub release"
    if: needs.detect-release.outputs.should-release == 'true'
    permissions:
      contents: write
    steps:
      - uses: actions/checkout@v4
      - name: Tag and release v${{ needs.detect-release.outputs.version }}
        env:
          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          VERSION: ${{ needs.detect-release.outputs.version }}
        run: |
          set -euo pipefail
          gh release create "v$VERSION" \
            --title "v$VERSION" \
            --target "$GITHUB_SHA" \
            --generate-notes