From 8bc2adf58abf7378d14731bf8ae72e4d18e8d1e5 Mon Sep 17 00:00:00 2001 From: hildebrind Date: Sun, 9 Jun 2024 13:02:06 -0400 Subject: [PATCH 01/26] add option to generate test coverage report without codecov --- .github/workflows/tox.yml | 28 ++++++++++++++++++++++++++++ docs/source/tox.rst | 4 ++-- 2 files changed, 30 insertions(+), 2 deletions(-) diff --git a/.github/workflows/tox.yml b/.github/workflows/tox.yml index aed72d9..9d21add 100644 --- a/.github/workflows/tox.yml +++ b/.github/workflows/tox.yml @@ -236,3 +236,31 @@ jobs: uses: codecov/codecov-action@5a1091511ad55cbe89839c7260b706298ca349f7 # v5.5.1 with: token: ${{ secrets.CODECOV_TOKEN }} + + - name: Upload coverage data + if: ${{ (success() || failure()) && contains(matrix.coverage, 'github') && matrix.pytest == 'true' }} + uses: actions/upload-artifact@v4 + with: + name: coverage-data-${{ matrix.os }}-${{ matrix.toxenv }} + path: coverage.xml + if-no-files-found: ignore + + coverage: + name: test coverage + needs: + - tox + if: inputs.coverage == 'github' + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - uses: actions/download-artifact@v4 + with: + pattern: coverage-data-* + merge-multiple: true + - uses: actions/setup-python@v5 + with: + python-version: "3.12" + - run: python -Im pip install --upgrade coverage[toml] + - run: python -Im coverage combine + - run: python -Im coverage report --format=markdown >> $GITHUB_STEP_SUMMARY + diff --git a/docs/source/tox.rst b/docs/source/tox.rst index 52c925f..c8ead83 100644 --- a/docs/source/tox.rst +++ b/docs/source/tox.rst @@ -162,8 +162,8 @@ This option has no effect if ``pytest`` is ``false``. coverage ^^^^^^^^ -A space separated list of coverage providers to upload to. Currently -only ``codecov`` is supported. Default is to not upload coverage +A space separated list of coverage providers to upload to, either +``codecov`` or ``github``. Default is to not upload coverage reports. See also, ``CODECOV_TOKEN`` secret. From 91f41704fb77f567fe61a7a420b7c44bbde79b50 Mon Sep 17 00:00:00 2001 From: Zach Burnett Date: Mon, 10 Jun 2024 13:40:30 -0400 Subject: [PATCH 02/26] update step name Co-authored-by: Stuart Mumford --- .github/workflows/tox.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/tox.yml b/.github/workflows/tox.yml index 9d21add..28ed402 100644 --- a/.github/workflows/tox.yml +++ b/.github/workflows/tox.yml @@ -237,7 +237,7 @@ jobs: with: token: ${{ secrets.CODECOV_TOKEN }} - - name: Upload coverage data + - name: Upload coverage data to GitHub if: ${{ (success() || failure()) && contains(matrix.coverage, 'github') && matrix.pytest == 'true' }} uses: actions/upload-artifact@v4 with: From b297ce49c10d69a19a50ac913b9659484f94c66f Mon Sep 17 00:00:00 2001 From: zacharyburnett Date: Mon, 10 Jun 2024 13:47:50 -0400 Subject: [PATCH 03/26] update matrix script --- .github/workflows/tox.yml | 3 +- tools/tox_matrix.py | 63 +++++++++++++++++++++++++++++---------- 2 files changed, 49 insertions(+), 17 deletions(-) diff --git a/.github/workflows/tox.yml b/.github/workflows/tox.yml index 28ed402..3e9a455 100644 --- a/.github/workflows/tox.yml +++ b/.github/workflows/tox.yml @@ -125,7 +125,7 @@ jobs: python-version: '3.12' - run: echo $TOX_MATRIX_SCRIPT | base64 --decode > tox_matrix.py env: - TOX_MATRIX_SCRIPT: # /// script
# requires-python = "==3.12"
# dependencies = [
#     "click==8.2.1",
#     "pyyaml==6.0.2",
# ]
# ///
import json
import os
import re

import click
import yaml


@click.command()
@click.option("--envs", default="")
@click.option("--libraries", default="")
@click.option("--posargs", default="")
@click.option("--toxdeps", default="")
@click.option("--toxargs", default="")
@click.option("--pytest", default="true")
@click.option("--pytest-results-summary", default="false")
@click.option("--coverage", default="")
@click.option("--conda", default="auto")
@click.option("--setenv", default="")
@click.option("--display", default="false")
@click.option("--cache-path", default="")
@click.option("--cache-key", default="")
@click.option("--cache-restore-keys", default="")
@click.option("--artifact-path", default="")
@click.option("--runs-on", default="")
@click.option("--default-python", default="")
@click.option("--timeout-minutes", default="360")
def load_tox_targets(envs, libraries, posargs, toxdeps, toxargs, pytest, pytest_results_summary,
                     coverage, conda, setenv, display, cache_path, cache_key,
                     cache_restore_keys, artifact_path, runs_on, default_python, timeout_minutes):
    """Script to load tox targets for GitHub Actions workflow."""
    # Load envs config
    envs = yaml.load(envs, Loader=yaml.BaseLoader)
    print(json.dumps(envs, indent=2))

    # Load global libraries config
    global_libraries = {
        "brew": [],
        "brew-cask": [],
        "apt": [],
        "choco": [],
    }
    libraries = yaml.load(libraries, Loader=yaml.BaseLoader)
    if libraries is not None:
        global_libraries.update(libraries)
    print(json.dumps(global_libraries, indent=2))

    # Default images to use for runners
    default_runs_on = {
        "linux": "ubuntu-latest",
        "macos": "macos-latest",
        "windows": "windows-latest",
    }
    custom_runs_on = yaml.load(runs_on, Loader=yaml.BaseLoader)
    if isinstance(custom_runs_on, dict):
        default_runs_on.update(custom_runs_on)
    print(json.dumps(default_runs_on, indent=2))

    # Default string parameters which can be overwritten by each env
    string_parameters = {
        "posargs": posargs,
        "toxdeps": toxdeps,
        "toxargs": toxargs,
        "pytest": pytest,
        "pytest-results-summary": pytest_results_summary,
        "coverage": coverage,
        "conda": conda,
        "setenv": setenv,
        "display": display,
        "cache-path": cache_path,
        "cache-key": cache_key,
        "cache-restore-keys": cache_restore_keys,
        "artifact-path": artifact_path,
        "timeout-minutes": timeout_minutes,
    }

    # Create matrix
    matrix = {"include": []}
    for env in envs:
        matrix["include"].append(get_matrix_item(
            env,
            global_libraries=global_libraries,
            global_string_parameters=string_parameters,
            runs_on=default_runs_on,
            default_python=default_python,
        ))

    # Output matrix
    print(json.dumps(matrix, indent=2))
    with open(os.environ["GITHUB_OUTPUT"], "a") as f:
        f.write(f"matrix={json.dumps(matrix)}\n")


def get_matrix_item(env, global_libraries, global_string_parameters,
                    runs_on, default_python):

    # define spec for each matrix include (+ global_string_parameters)
    item = {
        "os": None,
        "toxenv": None,
        "python_version": None,
        "name": None,
        "pytest_flag": None,
        "libraries_brew": None,
        "libraries_brew_cask": None,
        "libraries_apt": None,
        "libraries_choco": None,
        "cache-path": None,
        "cache-key": None,
        "cache-restore-keys": None,
        "artifact-name": None,
        "artifact-path": None,
        "timeout-minutes": None,
    }
    for string_param, default in global_string_parameters.items():
        env_value = env.get(string_param)
        item[string_param] = default if env_value is None else env_value

    # set os and toxenv
    for k, v in runs_on.items():
        if k in env:
            platform = k
            item["os"] = env.get("runs-on", v)
            item["toxenv"] = env[k]
    assert item["os"] is not None and item["toxenv"] is not None

    # set python_version
    python_version = env.get("python-version")
    m = re.search("^py(2|3)([0-9]+t?)", item["toxenv"])
    if python_version is not None:
        item["python_version"] = python_version
    elif m is not None:
        major, minor = m.groups()
        item["python_version"] = f"{major}.{minor}"
    else:
        item["python_version"] = env.get("default_python") or default_python

    # set name
    item["name"] = env.get("name") or f'{item["toxenv"]} ({item["os"]})'

    # set artifact-name (replace invalid path characters)
    item["artifact-name"] = re.sub(r"[\\ /:<>|*?\"']", "-", item["name"])
    item["artifact-name"] = re.sub(r"-+", "-", item["artifact-name"])

    # set pytest_flag
    item["pytest_flag"] = ""
    sep = r"\\" if platform == "windows" else "/"
    if item["pytest"] == "true" and "codecov" in item.get("coverage", ""):
        item["pytest_flag"] += (
            rf"--cov-report=xml:${{GITHUB_WORKSPACE}}{sep}coverage.xml ")
    if item["pytest"] == "true" and item["pytest-results-summary"] == "true":
        item["pytest_flag"] += rf"--junitxml ${{GITHUB_WORKSPACE}}{sep}results.xml "

    # set libraries
    env_libraries = env.get("libraries")
    if isinstance(env_libraries, str) and len(env_libraries.strip()) == 0:
        env_libraries = {}  # no libraries requested for environment
    libraries = global_libraries if env_libraries is None else env_libraries
    for manager in ["brew", "brew_cask", "apt", "choco"]:
        item[f"libraries_{manager}"] = " ".join(libraries.get(manager, []))

    # set "auto" conda value
    if item["conda"] == "auto":
        item["conda"] = "true" if "conda" in item["toxenv"] else "false"

    # inject toxdeps for conda
    if item["conda"] == "true" and "tox-conda" not in item["toxdeps"].lower():
        item["toxdeps"] = ("tox-conda " + item["toxdeps"]).strip()

    # make timeout-minutes a number
    item["timeout-minutes"] = int(item["timeout-minutes"])

    # verify values
    assert item["pytest"] in {"true", "false"}
    assert item["conda"] in {"true", "false"}
    assert item["display"] in {"true", "false"}

    return item


if __name__ == "__main__":
    load_tox_targets()
 + TOX_MATRIX_SCRIPT: import json
import os
import re

import click
import yaml
from packaging.version import InvalidVersion, Version


@click.command()
@click.option("--envs", default="")
@click.option("--libraries", default="")
@click.option("--posargs", default="")
@click.option("--toxdeps", default="")
@click.option("--toxargs", default="")
@click.option("--pytest", default="true")
@click.option("--pytest-results-summary", default="false")
@click.option("--coverage", default="")
@click.option("--conda", default="auto")
@click.option("--setenv", default="")
@click.option("--display", default="false")
@click.option("--cache-path", default="")
@click.option("--cache-key", default="")
@click.option("--cache-restore-keys", default="")
@click.option("--artifact-path", default="")
@click.option("--runs-on", default="")
@click.option("--default-python", default="")
@click.option("--timeout-minutes", default="360")
def load_tox_targets(
    envs,
    libraries,
    posargs,
    toxdeps,
    toxargs,
    pytest,
    pytest_results_summary,
    coverage,
    conda,
    setenv,
    display,
    cache_path,
    cache_key,
    cache_restore_keys,
    artifact_path,
    runs_on,
    default_python,
    timeout_minutes,
):
    """Script to load tox targets for GitHub Actions workflow."""
    # Load envs config
    envs = yaml.load(envs, Loader=yaml.BaseLoader)
    print(json.dumps(envs, indent=2))

    # Load global libraries config
    global_libraries = {
        "brew": [],
        "brew-cask": [],
        "apt": [],
        "choco": [],
    }
    libraries = yaml.load(libraries, Loader=yaml.BaseLoader)
    if libraries is not None:
        global_libraries.update(libraries)
    print(json.dumps(global_libraries, indent=2))

    # Default images to use for runners
    default_runs_on = {
        "linux": "ubuntu-latest",
        "macos": "macos-latest",
        "windows": "windows-latest",
    }
    custom_runs_on = yaml.load(runs_on, Loader=yaml.BaseLoader)
    if isinstance(custom_runs_on, dict):
        default_runs_on.update(custom_runs_on)
    print(json.dumps(default_runs_on, indent=2))

    # Default string parameters which can be overwritten by each env
    string_parameters = {
        "posargs": posargs,
        "toxdeps": toxdeps,
        "toxargs": toxargs,
        "pytest": pytest,
        "pytest-results-summary": pytest_results_summary,
        "coverage": coverage,
        "conda": conda,
        "setenv": setenv,
        "display": display,
        "cache-path": cache_path,
        "cache-key": cache_key,
        "cache-restore-keys": cache_restore_keys,
        "artifact-path": artifact_path,
        "timeout-minutes": timeout_minutes,
    }

    # Create matrix
    matrix = {"include": []}
    for env in envs:
        matrix["include"].append(
            get_matrix_item(
                env,
                global_libraries=global_libraries,
                global_string_parameters=string_parameters,
                runs_on=default_runs_on,
                default_python=default_python,
            )
        )

    # Output matrix
    print(json.dumps(matrix, indent=2))
    with open(os.environ["GITHUB_OUTPUT"], "a") as f:
        f.write(f"matrix={json.dumps(matrix)}\n")


def get_matrix_item(
    env, global_libraries, global_string_parameters, runs_on, default_python
):
    # define spec for each matrix include (+ global_string_parameters)
    item = {
        "os": None,
        "toxenv": None,
        "python_version": None,
        "name": None,
        "pytest_flag": None,
        "libraries_brew": None,
        "libraries_brew_cask": None,
        "libraries_apt": None,
        "libraries_choco": None,
        "cache-path": None,
        "cache-key": None,
        "cache-restore-keys": None,
        "artifact-name": None,
        "artifact-path": None,
        "timeout-minutes": None,
    }
    for string_param, default in global_string_parameters.items():
        env_value = env.get(string_param)
        item[string_param] = default if env_value is None else env_value

    # set os and toxenv
    for k, v in runs_on.items():
        if k in env:
            platform = k
            item["os"] = env.get("runs-on", v)
            item["toxenv"] = env[k]
    assert item["os"] is not None and item["toxenv"] is not None

    # set python_version
    python_version = env.get("python-version")
    m = re.search("^py(2|3)([0-9]+)", item["toxenv"])
    if python_version is not None:
        item["python_version"] = python_version
    elif m is not None:
        major, minor = m.groups()
        item["python_version"] = f"{major}.{minor}"
    else:
        item["python_version"] = env.get("default_python") or default_python

    # if Python is <3.10 we can't use macos-latest which is arm64
    try:
        if (
            Version(item["python_version"]) < Version("3.10")
            and item["os"] == "macos-latest"
        ):
            item["os"] = "macos-12"
    except InvalidVersion:
        # python_version might be for example 'pypy-3.10' which won't parse
        pass

    # set name
    item["name"] = env.get("name") or f'{item["toxenv"]} ({item["os"]})'

    # set artifact-name (replace invalid path characters)
    item["artifact-name"] = re.sub(r"[\\ /:<>|*?\"']", "-", item["name"])
    item["artifact-name"] = re.sub(r"-+", "-", item["artifact-name"])

    # set pytest_flag
    item["pytest_flag"] = ""
    sep = r"\\" if platform == "windows" else "/"
    if item["pytest"] == "true" and (
        "codecov" in item.get("coverage", "") or "github" in item.get("coverage", "")
    ):
        item["pytest_flag"] += (
            rf"--cov-report=xml:${{GITHUB_WORKSPACE}}{sep}coverage.xml "
        )
    if item["pytest"] == "true" and item["pytest-results-summary"] == "true":
        item["pytest_flag"] += rf"--junitxml ${{GITHUB_WORKSPACE}}{sep}results.xml "

    # set libraries
    env_libraries = env.get("libraries")
    if isinstance(env_libraries, str) and len(env_libraries.strip()) == 0:
        env_libraries = {}  # no libraries requested for environment
    libraries = global_libraries if env_libraries is None else env_libraries
    for manager in ["brew", "brew_cask", "apt", "choco"]:
        item[f"libraries_{manager}"] = " ".join(libraries.get(manager, []))

    # set "auto" conda value
    if item["conda"] == "auto":
        item["conda"] = "true" if "conda" in item["toxenv"] else "false"

    # inject toxdeps for conda
    if item["conda"] == "true" and "tox-conda" not in item["toxdeps"].lower():
        item["toxdeps"] = ("tox-conda " + item["toxdeps"]).strip()

    # make timeout-minutes a number
    item["timeout-minutes"] = int(item["timeout-minutes"])

    # verify values
    assert item["pytest"] in {"true", "false"}
    assert item["conda"] in {"true", "false"}
    assert item["display"] in {"true", "false"}

    return item


if __name__ == "__main__":
    load_tox_targets()
 - run: cat tox_matrix.py - id: set-outputs run: | @@ -263,4 +263,3 @@ jobs: - run: python -Im pip install --upgrade coverage[toml] - run: python -Im coverage combine - run: python -Im coverage report --format=markdown >> $GITHUB_STEP_SUMMARY - diff --git a/tools/tox_matrix.py b/tools/tox_matrix.py index f10a1a8..814369c 100644 --- a/tools/tox_matrix.py +++ b/tools/tox_matrix.py @@ -32,9 +32,26 @@ @click.option("--runs-on", default="") @click.option("--default-python", default="") @click.option("--timeout-minutes", default="360") -def load_tox_targets(envs, libraries, posargs, toxdeps, toxargs, pytest, pytest_results_summary, - coverage, conda, setenv, display, cache_path, cache_key, - cache_restore_keys, artifact_path, runs_on, default_python, timeout_minutes): +def load_tox_targets( + envs, + libraries, + posargs, + toxdeps, + toxargs, + pytest, + pytest_results_summary, + coverage, + conda, + setenv, + display, + cache_path, + cache_key, + cache_restore_keys, + artifact_path, + runs_on, + default_python, + timeout_minutes, +): """Script to load tox targets for GitHub Actions workflow.""" # Load envs config envs = yaml.load(envs, Loader=yaml.BaseLoader) @@ -84,13 +101,15 @@ def load_tox_targets(envs, libraries, posargs, toxdeps, toxargs, pytest, pytest_ # Create matrix matrix = {"include": []} for env in envs: - matrix["include"].append(get_matrix_item( - env, - global_libraries=global_libraries, - global_string_parameters=string_parameters, - runs_on=default_runs_on, - default_python=default_python, - )) + matrix["include"].append( + get_matrix_item( + env, + global_libraries=global_libraries, + global_string_parameters=string_parameters, + runs_on=default_runs_on, + default_python=default_python, + ) + ) # Output matrix print(json.dumps(matrix, indent=2)) @@ -98,9 +117,9 @@ def load_tox_targets(envs, libraries, posargs, toxdeps, toxargs, pytest, pytest_ f.write(f"matrix={json.dumps(matrix)}\n") -def get_matrix_item(env, global_libraries, global_string_parameters, - runs_on, default_python): - +def get_matrix_item( + env, global_libraries, global_string_parameters, runs_on, default_python +): # define spec for each matrix include (+ global_string_parameters) item = { "os": None, @@ -142,6 +161,17 @@ def get_matrix_item(env, global_libraries, global_string_parameters, else: item["python_version"] = env.get("default_python") or default_python + # if Python is <3.10 we can't use macos-latest which is arm64 + try: + if ( + Version(item["python_version"]) < Version("3.10") + and item["os"] == "macos-latest" + ): + item["os"] = "macos-12" + except InvalidVersion: + # python_version might be for example 'pypy-3.10' which won't parse + pass + # set name item["name"] = env.get("name") or f'{item["toxenv"]} ({item["os"]})' @@ -152,9 +182,12 @@ def get_matrix_item(env, global_libraries, global_string_parameters, # set pytest_flag item["pytest_flag"] = "" sep = r"\\" if platform == "windows" else "/" - if item["pytest"] == "true" and "codecov" in item.get("coverage", ""): + if item["pytest"] == "true" and ( + "codecov" in item.get("coverage", "") or "github" in item.get("coverage", "") + ): item["pytest_flag"] += ( - rf"--cov-report=xml:${{GITHUB_WORKSPACE}}{sep}coverage.xml ") + rf"--cov-report=xml:${{GITHUB_WORKSPACE}}{sep}coverage.xml " + ) if item["pytest"] == "true" and item["pytest-results-summary"] == "true": item["pytest_flag"] += rf"--junitxml ${{GITHUB_WORKSPACE}}{sep}results.xml " From 32d4115c9e794214c63f9cd803796fb895f71c24 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Mon, 10 Jun 2024 17:48:00 +0000 Subject: [PATCH 04/26] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- docs/source/tox.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/source/tox.rst b/docs/source/tox.rst index c8ead83..aa67128 100644 --- a/docs/source/tox.rst +++ b/docs/source/tox.rst @@ -162,7 +162,7 @@ This option has no effect if ``pytest`` is ``false``. coverage ^^^^^^^^ -A space separated list of coverage providers to upload to, either +A space separated list of coverage providers to upload to, either ``codecov`` or ``github``. Default is to not upload coverage reports. From 03f3d11a92671f0ae6d66f9d22b4a4bd8da49484 Mon Sep 17 00:00:00 2001 From: zacharyburnett Date: Tue, 11 Jun 2024 09:30:49 -0400 Subject: [PATCH 05/26] upload `.coverage.*` file to combine --- .github/workflows/tox.yml | 12 +++++++----- tools/tox_matrix.py | 18 ++++++++++-------- 2 files changed, 17 insertions(+), 13 deletions(-) diff --git a/.github/workflows/tox.yml b/.github/workflows/tox.yml index 3e9a455..da697db 100644 --- a/.github/workflows/tox.yml +++ b/.github/workflows/tox.yml @@ -125,7 +125,7 @@ jobs: python-version: '3.12' - run: echo $TOX_MATRIX_SCRIPT | base64 --decode > tox_matrix.py env: - TOX_MATRIX_SCRIPT: import json
import os
import re

import click
import yaml
from packaging.version import InvalidVersion, Version


@click.command()
@click.option("--envs", default="")
@click.option("--libraries", default="")
@click.option("--posargs", default="")
@click.option("--toxdeps", default="")
@click.option("--toxargs", default="")
@click.option("--pytest", default="true")
@click.option("--pytest-results-summary", default="false")
@click.option("--coverage", default="")
@click.option("--conda", default="auto")
@click.option("--setenv", default="")
@click.option("--display", default="false")
@click.option("--cache-path", default="")
@click.option("--cache-key", default="")
@click.option("--cache-restore-keys", default="")
@click.option("--artifact-path", default="")
@click.option("--runs-on", default="")
@click.option("--default-python", default="")
@click.option("--timeout-minutes", default="360")
def load_tox_targets(
    envs,
    libraries,
    posargs,
    toxdeps,
    toxargs,
    pytest,
    pytest_results_summary,
    coverage,
    conda,
    setenv,
    display,
    cache_path,
    cache_key,
    cache_restore_keys,
    artifact_path,
    runs_on,
    default_python,
    timeout_minutes,
):
    """Script to load tox targets for GitHub Actions workflow."""
    # Load envs config
    envs = yaml.load(envs, Loader=yaml.BaseLoader)
    print(json.dumps(envs, indent=2))

    # Load global libraries config
    global_libraries = {
        "brew": [],
        "brew-cask": [],
        "apt": [],
        "choco": [],
    }
    libraries = yaml.load(libraries, Loader=yaml.BaseLoader)
    if libraries is not None:
        global_libraries.update(libraries)
    print(json.dumps(global_libraries, indent=2))

    # Default images to use for runners
    default_runs_on = {
        "linux": "ubuntu-latest",
        "macos": "macos-latest",
        "windows": "windows-latest",
    }
    custom_runs_on = yaml.load(runs_on, Loader=yaml.BaseLoader)
    if isinstance(custom_runs_on, dict):
        default_runs_on.update(custom_runs_on)
    print(json.dumps(default_runs_on, indent=2))

    # Default string parameters which can be overwritten by each env
    string_parameters = {
        "posargs": posargs,
        "toxdeps": toxdeps,
        "toxargs": toxargs,
        "pytest": pytest,
        "pytest-results-summary": pytest_results_summary,
        "coverage": coverage,
        "conda": conda,
        "setenv": setenv,
        "display": display,
        "cache-path": cache_path,
        "cache-key": cache_key,
        "cache-restore-keys": cache_restore_keys,
        "artifact-path": artifact_path,
        "timeout-minutes": timeout_minutes,
    }

    # Create matrix
    matrix = {"include": []}
    for env in envs:
        matrix["include"].append(
            get_matrix_item(
                env,
                global_libraries=global_libraries,
                global_string_parameters=string_parameters,
                runs_on=default_runs_on,
                default_python=default_python,
            )
        )

    # Output matrix
    print(json.dumps(matrix, indent=2))
    with open(os.environ["GITHUB_OUTPUT"], "a") as f:
        f.write(f"matrix={json.dumps(matrix)}\n")


def get_matrix_item(
    env, global_libraries, global_string_parameters, runs_on, default_python
):
    # define spec for each matrix include (+ global_string_parameters)
    item = {
        "os": None,
        "toxenv": None,
        "python_version": None,
        "name": None,
        "pytest_flag": None,
        "libraries_brew": None,
        "libraries_brew_cask": None,
        "libraries_apt": None,
        "libraries_choco": None,
        "cache-path": None,
        "cache-key": None,
        "cache-restore-keys": None,
        "artifact-name": None,
        "artifact-path": None,
        "timeout-minutes": None,
    }
    for string_param, default in global_string_parameters.items():
        env_value = env.get(string_param)
        item[string_param] = default if env_value is None else env_value

    # set os and toxenv
    for k, v in runs_on.items():
        if k in env:
            platform = k
            item["os"] = env.get("runs-on", v)
            item["toxenv"] = env[k]
    assert item["os"] is not None and item["toxenv"] is not None

    # set python_version
    python_version = env.get("python-version")
    m = re.search("^py(2|3)([0-9]+)", item["toxenv"])
    if python_version is not None:
        item["python_version"] = python_version
    elif m is not None:
        major, minor = m.groups()
        item["python_version"] = f"{major}.{minor}"
    else:
        item["python_version"] = env.get("default_python") or default_python

    # if Python is <3.10 we can't use macos-latest which is arm64
    try:
        if (
            Version(item["python_version"]) < Version("3.10")
            and item["os"] == "macos-latest"
        ):
            item["os"] = "macos-12"
    except InvalidVersion:
        # python_version might be for example 'pypy-3.10' which won't parse
        pass

    # set name
    item["name"] = env.get("name") or f'{item["toxenv"]} ({item["os"]})'

    # set artifact-name (replace invalid path characters)
    item["artifact-name"] = re.sub(r"[\\ /:<>|*?\"']", "-", item["name"])
    item["artifact-name"] = re.sub(r"-+", "-", item["artifact-name"])

    # set pytest_flag
    item["pytest_flag"] = ""
    sep = r"\\" if platform == "windows" else "/"
    if item["pytest"] == "true" and (
        "codecov" in item.get("coverage", "") or "github" in item.get("coverage", "")
    ):
        item["pytest_flag"] += (
            rf"--cov-report=xml:${{GITHUB_WORKSPACE}}{sep}coverage.xml "
        )
    if item["pytest"] == "true" and item["pytest-results-summary"] == "true":
        item["pytest_flag"] += rf"--junitxml ${{GITHUB_WORKSPACE}}{sep}results.xml "

    # set libraries
    env_libraries = env.get("libraries")
    if isinstance(env_libraries, str) and len(env_libraries.strip()) == 0:
        env_libraries = {}  # no libraries requested for environment
    libraries = global_libraries if env_libraries is None else env_libraries
    for manager in ["brew", "brew_cask", "apt", "choco"]:
        item[f"libraries_{manager}"] = " ".join(libraries.get(manager, []))

    # set "auto" conda value
    if item["conda"] == "auto":
        item["conda"] = "true" if "conda" in item["toxenv"] else "false"

    # inject toxdeps for conda
    if item["conda"] == "true" and "tox-conda" not in item["toxdeps"].lower():
        item["toxdeps"] = ("tox-conda " + item["toxdeps"]).strip()

    # make timeout-minutes a number
    item["timeout-minutes"] = int(item["timeout-minutes"])

    # verify values
    assert item["pytest"] in {"true", "false"}
    assert item["conda"] in {"true", "false"}
    assert item["display"] in {"true", "false"}

    return item


if __name__ == "__main__":
    load_tox_targets()
 + TOX_MATRIX_SCRIPT: import json
import os
import re

import click
import yaml
from packaging.version import InvalidVersion, Version


@click.command()
@click.option("--envs", default="")
@click.option("--libraries", default="")
@click.option("--posargs", default="")
@click.option("--toxdeps", default="")
@click.option("--toxargs", default="")
@click.option("--pytest", default="true")
@click.option("--pytest-results-summary", default="false")
@click.option("--coverage", default="")
@click.option("--conda", default="auto")
@click.option("--setenv", default="")
@click.option("--display", default="false")
@click.option("--cache-path", default="")
@click.option("--cache-key", default="")
@click.option("--cache-restore-keys", default="")
@click.option("--artifact-path", default="")
@click.option("--runs-on", default="")
@click.option("--default-python", default="")
@click.option("--timeout-minutes", default="360")
def load_tox_targets(
    envs,
    libraries,
    posargs,
    toxdeps,
    toxargs,
    pytest,
    pytest_results_summary,
    coverage,
    conda,
    setenv,
    display,
    cache_path,
    cache_key,
    cache_restore_keys,
    artifact_path,
    runs_on,
    default_python,
    timeout_minutes,
):
    """Script to load tox targets for GitHub Actions workflow."""
    # Load envs config
    envs = yaml.load(envs, Loader=yaml.BaseLoader)
    print(json.dumps(envs, indent=2))

    # Load global libraries config
    global_libraries = {
        "brew": [],
        "brew-cask": [],
        "apt": [],
        "choco": [],
    }
    libraries = yaml.load(libraries, Loader=yaml.BaseLoader)
    if libraries is not None:
        global_libraries.update(libraries)
    print(json.dumps(global_libraries, indent=2))

    # Default images to use for runners
    default_runs_on = {
        "linux": "ubuntu-latest",
        "macos": "macos-latest",
        "windows": "windows-latest",
    }
    custom_runs_on = yaml.load(runs_on, Loader=yaml.BaseLoader)
    if isinstance(custom_runs_on, dict):
        default_runs_on.update(custom_runs_on)
    print(json.dumps(default_runs_on, indent=2))

    # Default string parameters which can be overwritten by each env
    string_parameters = {
        "posargs": posargs,
        "toxdeps": toxdeps,
        "toxargs": toxargs,
        "pytest": pytest,
        "pytest-results-summary": pytest_results_summary,
        "coverage": coverage,
        "conda": conda,
        "setenv": setenv,
        "display": display,
        "cache-path": cache_path,
        "cache-key": cache_key,
        "cache-restore-keys": cache_restore_keys,
        "artifact-path": artifact_path,
        "timeout-minutes": timeout_minutes,
    }

    # Create matrix
    matrix = {"include": []}
    for env in envs:
        matrix["include"].append(
            get_matrix_item(
                env,
                global_libraries=global_libraries,
                global_string_parameters=string_parameters,
                runs_on=default_runs_on,
                default_python=default_python,
            )
        )

    # Output matrix
    print(json.dumps(matrix, indent=2))
    with open(os.environ["GITHUB_OUTPUT"], "a") as f:
        f.write(f"matrix={json.dumps(matrix)}\n")


def get_matrix_item(
    env, global_libraries, global_string_parameters, runs_on, default_python
):
    # define spec for each matrix include (+ global_string_parameters)
    item = {
        "os": None,
        "toxenv": None,
        "python_version": None,
        "name": None,
        "pytest_flag": None,
        "libraries_brew": None,
        "libraries_brew_cask": None,
        "libraries_apt": None,
        "libraries_choco": None,
        "cache-path": None,
        "cache-key": None,
        "cache-restore-keys": None,
        "artifact-name": None,
        "artifact-path": None,
        "timeout-minutes": None,
    }
    for string_param, default in global_string_parameters.items():
        env_value = env.get(string_param)
        item[string_param] = default if env_value is None else env_value

    # set os and toxenv
    for k, v in runs_on.items():
        if k in env:
            platform = k
            item["os"] = env.get("runs-on", v)
            item["toxenv"] = env[k]
    assert item["os"] is not None and item["toxenv"] is not None

    # set python_version
    python_version = env.get("python-version")
    m = re.search("^py(2|3)([0-9]+)", item["toxenv"])
    if python_version is not None:
        item["python_version"] = python_version
    elif m is not None:
        major, minor = m.groups()
        item["python_version"] = f"{major}.{minor}"
    else:
        item["python_version"] = env.get("default_python") or default_python

    # if Python is <3.10 we can't use macos-latest which is arm64
    try:
        if (
            Version(item["python_version"]) < Version("3.10")
            and item["os"] == "macos-latest"
        ):
            item["os"] = "macos-12"
    except InvalidVersion:
        # python_version might be for example 'pypy-3.10' which won't parse
        pass

    # set name
    item["name"] = env.get("name") or f'{item["toxenv"]} ({item["os"]})'

    # set artifact-name (replace invalid path characters)
    item["artifact-name"] = re.sub(r"[\\ /:<>|*?\"']", "-", item["name"])
    item["artifact-name"] = re.sub(r"-+", "-", item["artifact-name"])

    # set pytest_flag
    item["pytest_flag"] = ""
    sep = r"\\" if platform == "windows" else "/"
    if item["pytest"] == "true":
        if "codecov" in item.get("coverage", ""):
            item["pytest_flag"] += (
                rf"--cov --cov-report=xml:${{GITHUB_WORKSPACE}}{sep}coverage.xml "
            )
        elif "github" in item.get("coverage", ""):
            item["pytest_flag"] += "--cov "

        if item["pytest-results-summary"] == "true":
            item["pytest_flag"] += rf"--junitxml ${{GITHUB_WORKSPACE}}{sep}results.xml "

    # set libraries
    env_libraries = env.get("libraries")
    if isinstance(env_libraries, str) and len(env_libraries.strip()) == 0:
        env_libraries = {}  # no libraries requested for environment
    libraries = global_libraries if env_libraries is None else env_libraries
    for manager in ["brew", "brew_cask", "apt", "choco"]:
        item[f"libraries_{manager}"] = " ".join(libraries.get(manager, []))

    # set "auto" conda value
    if item["conda"] == "auto":
        item["conda"] = "true" if "conda" in item["toxenv"] else "false"

    # inject toxdeps for conda
    if item["conda"] == "true" and "tox-conda" not in item["toxdeps"].lower():
        item["toxdeps"] = ("tox-conda " + item["toxdeps"]).strip()

    # make timeout-minutes a number
    item["timeout-minutes"] = int(item["timeout-minutes"])

    # verify values
    assert item["pytest"] in {"true", "false"}
    assert item["conda"] in {"true", "false"}
    assert item["display"] in {"true", "false"}

    return item


if __name__ == "__main__":
    load_tox_targets()
 - run: cat tox_matrix.py - id: set-outputs run: | @@ -237,13 +237,15 @@ jobs: with: token: ${{ secrets.CODECOV_TOKEN }} + - if: ${{ (success() || failure()) && contains(matrix.coverage, 'github') && matrix.pytest == 'true' }} + run: mv .coverage .coverage.${{ matrix.os }}-${{ matrix.toxenv }} + - name: Upload coverage data to GitHub if: ${{ (success() || failure()) && contains(matrix.coverage, 'github') && matrix.pytest == 'true' }} uses: actions/upload-artifact@v4 with: - name: coverage-data-${{ matrix.os }}-${{ matrix.toxenv }} - path: coverage.xml - if-no-files-found: ignore + name: .coverage.${{ matrix.os }}-${{ matrix.toxenv }} + path: .coverage.${{ matrix.os }}-${{ matrix.toxenv }} coverage: name: test coverage @@ -255,7 +257,7 @@ jobs: - uses: actions/checkout@v4 - uses: actions/download-artifact@v4 with: - pattern: coverage-data-* + pattern: .coverage.* merge-multiple: true - uses: actions/setup-python@v5 with: diff --git a/tools/tox_matrix.py b/tools/tox_matrix.py index 814369c..b2f7e17 100644 --- a/tools/tox_matrix.py +++ b/tools/tox_matrix.py @@ -182,14 +182,16 @@ def get_matrix_item( # set pytest_flag item["pytest_flag"] = "" sep = r"\\" if platform == "windows" else "/" - if item["pytest"] == "true" and ( - "codecov" in item.get("coverage", "") or "github" in item.get("coverage", "") - ): - item["pytest_flag"] += ( - rf"--cov-report=xml:${{GITHUB_WORKSPACE}}{sep}coverage.xml " - ) - if item["pytest"] == "true" and item["pytest-results-summary"] == "true": - item["pytest_flag"] += rf"--junitxml ${{GITHUB_WORKSPACE}}{sep}results.xml " + if item["pytest"] == "true": + if "codecov" in item.get("coverage", ""): + item["pytest_flag"] += ( + rf"--cov --cov-report=xml:${{GITHUB_WORKSPACE}}{sep}coverage.xml " + ) + elif "github" in item.get("coverage", ""): + item["pytest_flag"] += "--cov " + + if item["pytest-results-summary"] == "true": + item["pytest_flag"] += rf"--junitxml ${{GITHUB_WORKSPACE}}{sep}results.xml " # set libraries env_libraries = env.get("libraries") From 7d1182422da4432159eda746c741faaee89cafa7 Mon Sep 17 00:00:00 2001 From: zacharyburnett Date: Fri, 21 Jun 2024 09:21:59 -0400 Subject: [PATCH 06/26] list files --- .github/workflows/tox.yml | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/.github/workflows/tox.yml b/.github/workflows/tox.yml index da697db..16d23b9 100644 --- a/.github/workflows/tox.yml +++ b/.github/workflows/tox.yml @@ -238,7 +238,9 @@ jobs: token: ${{ secrets.CODECOV_TOKEN }} - if: ${{ (success() || failure()) && contains(matrix.coverage, 'github') && matrix.pytest == 'true' }} - run: mv .coverage .coverage.${{ matrix.os }}-${{ matrix.toxenv }} + run: | + mv .coverage .coverage.${{ matrix.os }}-${{ matrix.toxenv }} + ls -la . - name: Upload coverage data to GitHub if: ${{ (success() || failure()) && contains(matrix.coverage, 'github') && matrix.pytest == 'true' }} From 2c4aa19991f96fbf6efcc0ccf5b7e906ecb5a6f9 Mon Sep 17 00:00:00 2001 From: zacharyburnett Date: Fri, 21 Jun 2024 09:50:19 -0400 Subject: [PATCH 07/26] use runner.os instead of matrix value --- .github/workflows/tox.yml | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/.github/workflows/tox.yml b/.github/workflows/tox.yml index 16d23b9..400b2ce 100644 --- a/.github/workflows/tox.yml +++ b/.github/workflows/tox.yml @@ -239,15 +239,15 @@ jobs: - if: ${{ (success() || failure()) && contains(matrix.coverage, 'github') && matrix.pytest == 'true' }} run: | - mv .coverage .coverage.${{ matrix.os }}-${{ matrix.toxenv }} + mv .coverage .coverage.${{ runner.os }}-${{ matrix.toxenv }} ls -la . - name: Upload coverage data to GitHub if: ${{ (success() || failure()) && contains(matrix.coverage, 'github') && matrix.pytest == 'true' }} uses: actions/upload-artifact@v4 with: - name: .coverage.${{ matrix.os }}-${{ matrix.toxenv }} - path: .coverage.${{ matrix.os }}-${{ matrix.toxenv }} + name: .coverage.${{ runner.os }}-${{ matrix.toxenv }} + path: .coverage.${{ runner.os }}-${{ matrix.toxenv }} coverage: name: test coverage From d3a9592f98c7d5df0596742653361755b8178e3b Mon Sep 17 00:00:00 2001 From: zacharyburnett Date: Fri, 21 Jun 2024 12:59:57 -0400 Subject: [PATCH 08/26] combine and report coverage --- .github/workflows/tox.yml | 22 +++++++++++++++------- 1 file changed, 15 insertions(+), 7 deletions(-) diff --git a/.github/workflows/tox.yml b/.github/workflows/tox.yml index 400b2ce..1ce0156 100644 --- a/.github/workflows/tox.yml +++ b/.github/workflows/tox.yml @@ -117,8 +117,6 @@ jobs: envs: name: Load tox environments runs-on: ubuntu-latest - outputs: - matrix: ${{ steps.set-outputs.outputs.matrix }} steps: - uses: actions/setup-python@e797f83bcb11b83ae66e0230d6156d7c80228e7c # v6.0.0 with: @@ -141,6 +139,8 @@ jobs: --runs-on "${{ inputs.runs-on }}" --default-python "${{ inputs.default_python }}" \ --timeout-minutes "${{ inputs.timeout-minutes }}" shell: sh + outputs: + matrix: ${{ steps.set-outputs.outputs.matrix }} tox: name: ${{ matrix.name }} @@ -239,24 +239,28 @@ jobs: - if: ${{ (success() || failure()) && contains(matrix.coverage, 'github') && matrix.pytest == 'true' }} run: | - mv .coverage .coverage.${{ runner.os }}-${{ matrix.toxenv }} + mv .coverage .coverage.${{ runner.os }}-${{ runner.arch }}-${{ matrix.toxenv }} ls -la . - name: Upload coverage data to GitHub if: ${{ (success() || failure()) && contains(matrix.coverage, 'github') && matrix.pytest == 'true' }} uses: actions/upload-artifact@v4 with: - name: .coverage.${{ runner.os }}-${{ matrix.toxenv }} - path: .coverage.${{ runner.os }}-${{ matrix.toxenv }} + name: .coverage.${{ runner.os }}-${{ runner.arch }}-${{ matrix.toxenv }} + path: .coverage.${{ runner.os }}-${{ runner.arch }}-${{ matrix.toxenv }} coverage: name: test coverage needs: - tox - if: inputs.coverage == 'github' runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 + with: + fetch-depth: 0 + lfs: true + submodules: ${{ inputs.submodules }} + ref: ${{ inputs.checkout_ref }} - uses: actions/download-artifact@v4 with: pattern: .coverage.* @@ -264,6 +268,10 @@ jobs: - uses: actions/setup-python@v5 with: python-version: "3.12" + continue-on-error: true - run: python -Im pip install --upgrade coverage[toml] + continue-on-error: true - run: python -Im coverage combine - - run: python -Im coverage report --format=markdown >> $GITHUB_STEP_SUMMARY + continue-on-error: true + - run: python -Im coverage report -i -m --format=markdown >> $GITHUB_STEP_SUMMARY + continue-on-error: true From 8f004313143e1eb8dbb494e0d81e809c24348e3f Mon Sep 17 00:00:00 2001 From: zacharyburnett Date: Fri, 21 Jun 2024 15:37:35 -0400 Subject: [PATCH 09/26] undo style formatting --- .github/workflows/tox.yml | 2 +- tools/tox_matrix.py | 50 +++++++++++---------------------------- 2 files changed, 15 insertions(+), 37 deletions(-) diff --git a/.github/workflows/tox.yml b/.github/workflows/tox.yml index 1ce0156..c3ed1f0 100644 --- a/.github/workflows/tox.yml +++ b/.github/workflows/tox.yml @@ -123,7 +123,7 @@ jobs: python-version: '3.12' - run: echo $TOX_MATRIX_SCRIPT | base64 --decode > tox_matrix.py env: - TOX_MATRIX_SCRIPT: import json
import os
import re

import click
import yaml
from packaging.version import InvalidVersion, Version


@click.command()
@click.option("--envs", default="")
@click.option("--libraries", default="")
@click.option("--posargs", default="")
@click.option("--toxdeps", default="")
@click.option("--toxargs", default="")
@click.option("--pytest", default="true")
@click.option("--pytest-results-summary", default="false")
@click.option("--coverage", default="")
@click.option("--conda", default="auto")
@click.option("--setenv", default="")
@click.option("--display", default="false")
@click.option("--cache-path", default="")
@click.option("--cache-key", default="")
@click.option("--cache-restore-keys", default="")
@click.option("--artifact-path", default="")
@click.option("--runs-on", default="")
@click.option("--default-python", default="")
@click.option("--timeout-minutes", default="360")
def load_tox_targets(
    envs,
    libraries,
    posargs,
    toxdeps,
    toxargs,
    pytest,
    pytest_results_summary,
    coverage,
    conda,
    setenv,
    display,
    cache_path,
    cache_key,
    cache_restore_keys,
    artifact_path,
    runs_on,
    default_python,
    timeout_minutes,
):
    """Script to load tox targets for GitHub Actions workflow."""
    # Load envs config
    envs = yaml.load(envs, Loader=yaml.BaseLoader)
    print(json.dumps(envs, indent=2))

    # Load global libraries config
    global_libraries = {
        "brew": [],
        "brew-cask": [],
        "apt": [],
        "choco": [],
    }
    libraries = yaml.load(libraries, Loader=yaml.BaseLoader)
    if libraries is not None:
        global_libraries.update(libraries)
    print(json.dumps(global_libraries, indent=2))

    # Default images to use for runners
    default_runs_on = {
        "linux": "ubuntu-latest",
        "macos": "macos-latest",
        "windows": "windows-latest",
    }
    custom_runs_on = yaml.load(runs_on, Loader=yaml.BaseLoader)
    if isinstance(custom_runs_on, dict):
        default_runs_on.update(custom_runs_on)
    print(json.dumps(default_runs_on, indent=2))

    # Default string parameters which can be overwritten by each env
    string_parameters = {
        "posargs": posargs,
        "toxdeps": toxdeps,
        "toxargs": toxargs,
        "pytest": pytest,
        "pytest-results-summary": pytest_results_summary,
        "coverage": coverage,
        "conda": conda,
        "setenv": setenv,
        "display": display,
        "cache-path": cache_path,
        "cache-key": cache_key,
        "cache-restore-keys": cache_restore_keys,
        "artifact-path": artifact_path,
        "timeout-minutes": timeout_minutes,
    }

    # Create matrix
    matrix = {"include": []}
    for env in envs:
        matrix["include"].append(
            get_matrix_item(
                env,
                global_libraries=global_libraries,
                global_string_parameters=string_parameters,
                runs_on=default_runs_on,
                default_python=default_python,
            )
        )

    # Output matrix
    print(json.dumps(matrix, indent=2))
    with open(os.environ["GITHUB_OUTPUT"], "a") as f:
        f.write(f"matrix={json.dumps(matrix)}\n")


def get_matrix_item(
    env, global_libraries, global_string_parameters, runs_on, default_python
):
    # define spec for each matrix include (+ global_string_parameters)
    item = {
        "os": None,
        "toxenv": None,
        "python_version": None,
        "name": None,
        "pytest_flag": None,
        "libraries_brew": None,
        "libraries_brew_cask": None,
        "libraries_apt": None,
        "libraries_choco": None,
        "cache-path": None,
        "cache-key": None,
        "cache-restore-keys": None,
        "artifact-name": None,
        "artifact-path": None,
        "timeout-minutes": None,
    }
    for string_param, default in global_string_parameters.items():
        env_value = env.get(string_param)
        item[string_param] = default if env_value is None else env_value

    # set os and toxenv
    for k, v in runs_on.items():
        if k in env:
            platform = k
            item["os"] = env.get("runs-on", v)
            item["toxenv"] = env[k]
    assert item["os"] is not None and item["toxenv"] is not None

    # set python_version
    python_version = env.get("python-version")
    m = re.search("^py(2|3)([0-9]+)", item["toxenv"])
    if python_version is not None:
        item["python_version"] = python_version
    elif m is not None:
        major, minor = m.groups()
        item["python_version"] = f"{major}.{minor}"
    else:
        item["python_version"] = env.get("default_python") or default_python

    # if Python is <3.10 we can't use macos-latest which is arm64
    try:
        if (
            Version(item["python_version"]) < Version("3.10")
            and item["os"] == "macos-latest"
        ):
            item["os"] = "macos-12"
    except InvalidVersion:
        # python_version might be for example 'pypy-3.10' which won't parse
        pass

    # set name
    item["name"] = env.get("name") or f'{item["toxenv"]} ({item["os"]})'

    # set artifact-name (replace invalid path characters)
    item["artifact-name"] = re.sub(r"[\\ /:<>|*?\"']", "-", item["name"])
    item["artifact-name"] = re.sub(r"-+", "-", item["artifact-name"])

    # set pytest_flag
    item["pytest_flag"] = ""
    sep = r"\\" if platform == "windows" else "/"
    if item["pytest"] == "true":
        if "codecov" in item.get("coverage", ""):
            item["pytest_flag"] += (
                rf"--cov --cov-report=xml:${{GITHUB_WORKSPACE}}{sep}coverage.xml "
            )
        elif "github" in item.get("coverage", ""):
            item["pytest_flag"] += "--cov "

        if item["pytest-results-summary"] == "true":
            item["pytest_flag"] += rf"--junitxml ${{GITHUB_WORKSPACE}}{sep}results.xml "

    # set libraries
    env_libraries = env.get("libraries")
    if isinstance(env_libraries, str) and len(env_libraries.strip()) == 0:
        env_libraries = {}  # no libraries requested for environment
    libraries = global_libraries if env_libraries is None else env_libraries
    for manager in ["brew", "brew_cask", "apt", "choco"]:
        item[f"libraries_{manager}"] = " ".join(libraries.get(manager, []))

    # set "auto" conda value
    if item["conda"] == "auto":
        item["conda"] = "true" if "conda" in item["toxenv"] else "false"

    # inject toxdeps for conda
    if item["conda"] == "true" and "tox-conda" not in item["toxdeps"].lower():
        item["toxdeps"] = ("tox-conda " + item["toxdeps"]).strip()

    # make timeout-minutes a number
    item["timeout-minutes"] = int(item["timeout-minutes"])

    # verify values
    assert item["pytest"] in {"true", "false"}
    assert item["conda"] in {"true", "false"}
    assert item["display"] in {"true", "false"}

    return item


if __name__ == "__main__":
    load_tox_targets()
 + TOX_MATRIX_SCRIPT: import json
import os
import re

import click
import yaml
from packaging.version import InvalidVersion, Version


@click.command()
@click.option("--envs", default="")
@click.option("--libraries", default="")
@click.option("--posargs", default="")
@click.option("--toxdeps", default="")
@click.option("--toxargs", default="")
@click.option("--pytest", default="true")
@click.option("--pytest-results-summary", default="false")
@click.option("--coverage", default="")
@click.option("--conda", default="auto")
@click.option("--setenv", default="")
@click.option("--display", default="false")
@click.option("--cache-path", default="")
@click.option("--cache-key", default="")
@click.option("--cache-restore-keys", default="")
@click.option("--artifact-path", default="")
@click.option("--runs-on", default="")
@click.option("--default-python", default="")
@click.option("--timeout-minutes", default="360")
def load_tox_targets(envs, libraries, posargs, toxdeps, toxargs, pytest, pytest_results_summary,
                     coverage, conda, setenv, display, cache_path, cache_key,
                     cache_restore_keys, artifact_path, runs_on, default_python, timeout_minutes):
    """Script to load tox targets for GitHub Actions workflow."""
    # Load envs config
    envs = yaml.load(envs, Loader=yaml.BaseLoader)
    print(json.dumps(envs, indent=2))

    # Load global libraries config
    global_libraries = {
        "brew": [],
        "brew-cask": [],
        "apt": [],
        "choco": [],
    }
    libraries = yaml.load(libraries, Loader=yaml.BaseLoader)
    if libraries is not None:
        global_libraries.update(libraries)
    print(json.dumps(global_libraries, indent=2))

    # Default images to use for runners
    default_runs_on = {
        "linux": "ubuntu-latest",
        "macos": "macos-latest",
        "windows": "windows-latest",
    }
    custom_runs_on = yaml.load(runs_on, Loader=yaml.BaseLoader)
    if isinstance(custom_runs_on, dict):
        default_runs_on.update(custom_runs_on)
    print(json.dumps(default_runs_on, indent=2))

    # Default string parameters which can be overwritten by each env
    string_parameters = {
        "posargs": posargs,
        "toxdeps": toxdeps,
        "toxargs": toxargs,
        "pytest": pytest,
        "pytest-results-summary": pytest_results_summary,
        "coverage": coverage,
        "conda": conda,
        "setenv": setenv,
        "display": display,
        "cache-path": cache_path,
        "cache-key": cache_key,
        "cache-restore-keys": cache_restore_keys,
        "artifact-path": artifact_path,
        "timeout-minutes": timeout_minutes,
    }

    # Create matrix
    matrix = {"include": []}
    for env in envs:
        matrix["include"].append(get_matrix_item(
            env,
            global_libraries=global_libraries,
            global_string_parameters=string_parameters,
            runs_on=default_runs_on,
            default_python=default_python,
        ))

    # Output matrix
    print(json.dumps(matrix, indent=2))
    with open(os.environ["GITHUB_OUTPUT"], "a") as f:
        f.write(f"matrix={json.dumps(matrix)}\n")


def get_matrix_item(env, global_libraries, global_string_parameters,
                    runs_on, default_python):

    # define spec for each matrix include (+ global_string_parameters)
    item = {
        "os": None,
        "toxenv": None,
        "python_version": None,
        "name": None,
        "pytest_flag": None,
        "libraries_brew": None,
        "libraries_brew_cask": None,
        "libraries_apt": None,
        "libraries_choco": None,
        "cache-path": None,
        "cache-key": None,
        "cache-restore-keys": None,
        "artifact-name": None,
        "artifact-path": None,
        "timeout-minutes": None,
    }
    for string_param, default in global_string_parameters.items():
        env_value = env.get(string_param)
        item[string_param] = default if env_value is None else env_value

    # set os and toxenv
    for k, v in runs_on.items():
        if k in env:
            platform = k
            item["os"] = env.get("runs-on", v)
            item["toxenv"] = env[k]
    assert item["os"] is not None and item["toxenv"] is not None

    # set python_version
    python_version = env.get("python-version")
    m = re.search("^py(2|3)([0-9]+)", item["toxenv"])
    if python_version is not None:
        item["python_version"] = python_version
    elif m is not None:
        major, minor = m.groups()
        item["python_version"] = f"{major}.{minor}"
    else:
        item["python_version"] = env.get("default_python") or default_python

    # if Python is <3.10 we can't use macos-latest which is arm64
    try:
        if Version(item["python_version"]) < Version('3.10') and item["os"] == "macos-latest":
            item["os"] = "macos-12"
    except InvalidVersion:
        # python_version might be for example 'pypy-3.10' which won't parse
        pass

    # set name
    item["name"] = env.get("name") or f'{item["toxenv"]} ({item["os"]})'

    # set artifact-name (replace invalid path characters)
    item["artifact-name"] = re.sub(r"[\\ /:<>|*?\"']", "-", item["name"])
    item["artifact-name"] = re.sub(r"-+", "-", item["artifact-name"])

    # set pytest_flag
    item["pytest_flag"] = ""
    sep = r"\\" if platform == "windows" else "/"
    if item["pytest"] == "true":
        if "codecov" in item.get("coverage", ""):
            item["pytest_flag"] += (
                rf"--cov --cov-report=xml:${{GITHUB_WORKSPACE}}{sep}coverage.xml "
            )
        elif "github" in item.get("coverage", ""):
            item["pytest_flag"] += "--cov "

        if item["pytest-results-summary"] == "true":
            item["pytest_flag"] += rf"--junitxml ${{GITHUB_WORKSPACE}}{sep}results.xml "

    # set libraries
    env_libraries = env.get("libraries")
    if isinstance(env_libraries, str) and len(env_libraries.strip()) == 0:
        env_libraries = {}  # no libraries requested for environment
    libraries = global_libraries if env_libraries is None else env_libraries
    for manager in ["brew", "brew_cask", "apt", "choco"]:
        item[f"libraries_{manager}"] = " ".join(libraries.get(manager, []))

    # set "auto" conda value
    if item["conda"] == "auto":
        item["conda"] = "true" if "conda" in item["toxenv"] else "false"

    # inject toxdeps for conda
    if item["conda"] == "true" and "tox-conda" not in item["toxdeps"].lower():
        item["toxdeps"] = ("tox-conda " + item["toxdeps"]).strip()

    # make timeout-minutes a number
    item["timeout-minutes"] = int(item["timeout-minutes"])

    # verify values
    assert item["pytest"] in {"true", "false"}
    assert item["conda"] in {"true", "false"}
    assert item["display"] in {"true", "false"}

    return item


if __name__ == "__main__":
    load_tox_targets()
 - run: cat tox_matrix.py - id: set-outputs run: | diff --git a/tools/tox_matrix.py b/tools/tox_matrix.py index b2f7e17..7b62cc7 100644 --- a/tools/tox_matrix.py +++ b/tools/tox_matrix.py @@ -32,26 +32,9 @@ @click.option("--runs-on", default="") @click.option("--default-python", default="") @click.option("--timeout-minutes", default="360") -def load_tox_targets( - envs, - libraries, - posargs, - toxdeps, - toxargs, - pytest, - pytest_results_summary, - coverage, - conda, - setenv, - display, - cache_path, - cache_key, - cache_restore_keys, - artifact_path, - runs_on, - default_python, - timeout_minutes, -): +def load_tox_targets(envs, libraries, posargs, toxdeps, toxargs, pytest, pytest_results_summary, + coverage, conda, setenv, display, cache_path, cache_key, + cache_restore_keys, artifact_path, runs_on, default_python, timeout_minutes): """Script to load tox targets for GitHub Actions workflow.""" # Load envs config envs = yaml.load(envs, Loader=yaml.BaseLoader) @@ -101,15 +84,13 @@ def load_tox_targets( # Create matrix matrix = {"include": []} for env in envs: - matrix["include"].append( - get_matrix_item( - env, - global_libraries=global_libraries, - global_string_parameters=string_parameters, - runs_on=default_runs_on, - default_python=default_python, - ) - ) + matrix["include"].append(get_matrix_item( + env, + global_libraries=global_libraries, + global_string_parameters=string_parameters, + runs_on=default_runs_on, + default_python=default_python, + )) # Output matrix print(json.dumps(matrix, indent=2)) @@ -117,9 +98,9 @@ def load_tox_targets( f.write(f"matrix={json.dumps(matrix)}\n") -def get_matrix_item( - env, global_libraries, global_string_parameters, runs_on, default_python -): +def get_matrix_item(env, global_libraries, global_string_parameters, + runs_on, default_python): + # define spec for each matrix include (+ global_string_parameters) item = { "os": None, @@ -163,10 +144,7 @@ def get_matrix_item( # if Python is <3.10 we can't use macos-latest which is arm64 try: - if ( - Version(item["python_version"]) < Version("3.10") - and item["os"] == "macos-latest" - ): + if Version(item["python_version"]) < Version('3.10') and item["os"] == "macos-latest": item["os"] = "macos-12" except InvalidVersion: # python_version might be for example 'pypy-3.10' which won't parse From f3c3d29e76dfd66c05575111e3619855c6df31ca Mon Sep 17 00:00:00 2001 From: zacharyburnett Date: Fri, 21 Jun 2024 15:41:34 -0400 Subject: [PATCH 10/26] set run shell --- .github/workflows/tox.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/tox.yml b/.github/workflows/tox.yml index c3ed1f0..62688d0 100644 --- a/.github/workflows/tox.yml +++ b/.github/workflows/tox.yml @@ -241,6 +241,7 @@ jobs: run: | mv .coverage .coverage.${{ runner.os }}-${{ runner.arch }}-${{ matrix.toxenv }} ls -la . + shell: sh - name: Upload coverage data to GitHub if: ${{ (success() || failure()) && contains(matrix.coverage, 'github') && matrix.pytest == 'true' }} From 2e7203a22c4c96183a2e2c11e3bb4b379a089e26 Mon Sep 17 00:00:00 2001 From: zacharyburnett Date: Fri, 21 Jun 2024 15:43:15 -0400 Subject: [PATCH 11/26] set job name as `report coverage` to be explicit --- .github/workflows/tox.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/tox.yml b/.github/workflows/tox.yml index 62688d0..5a98646 100644 --- a/.github/workflows/tox.yml +++ b/.github/workflows/tox.yml @@ -251,7 +251,7 @@ jobs: path: .coverage.${{ runner.os }}-${{ runner.arch }}-${{ matrix.toxenv }} coverage: - name: test coverage + name: report coverage needs: - tox runs-on: ubuntu-latest From 9660cce2284c4c12b01912dfc071a154e7549ca1 Mon Sep 17 00:00:00 2001 From: zacharyburnett Date: Mon, 24 Jun 2024 13:38:10 -0400 Subject: [PATCH 12/26] use conditional ifs instead of continue-of-error --- .github/workflows/tox.yml | 26 +++++++++++++++++--------- 1 file changed, 17 insertions(+), 9 deletions(-) diff --git a/.github/workflows/tox.yml b/.github/workflows/tox.yml index 5a98646..1095a3e 100644 --- a/.github/workflows/tox.yml +++ b/.github/workflows/tox.yml @@ -258,7 +258,6 @@ jobs: steps: - uses: actions/checkout@v4 with: - fetch-depth: 0 lfs: true submodules: ${{ inputs.submodules }} ref: ${{ inputs.checkout_ref }} @@ -266,13 +265,22 @@ jobs: with: pattern: .coverage.* merge-multiple: true - - uses: actions/setup-python@v5 + - id: check_downloaded_files + run: | + [ "$(ls -A .coverage*)" ] && exit 0 || exit 1 + continue-on-error: true + - if: steps.check_downloaded_files.outcome == 'success' + uses: actions/setup-python@v5 with: python-version: "3.12" - continue-on-error: true - - run: python -Im pip install --upgrade coverage[toml] - continue-on-error: true - - run: python -Im coverage combine - continue-on-error: true - - run: python -Im coverage report -i -m --format=markdown >> $GITHUB_STEP_SUMMARY - continue-on-error: true + - if: steps.check_downloaded_files.outcome == 'success' + name: generate coverage report + run: | + python -Im pip install --upgrade coverage[toml] + python -Im coverage combine + python -Im coverage report -i -m --format=markdown >> $GITHUB_STEP_SUMMARY + - if: steps.check_downloaded_files.outcome == 'success' + uses: actions/upload-artifact@v4 + with: + name: .coverage + path: .coverage From 12c54557896a44eda43fde5bc7beec4ac4827bb1 Mon Sep 17 00:00:00 2001 From: zacharyburnett Date: Wed, 26 Jun 2024 09:43:39 -0400 Subject: [PATCH 13/26] reorder ls and mv --- .github/workflows/tox.yml | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.github/workflows/tox.yml b/.github/workflows/tox.yml index 1095a3e..e799cf3 100644 --- a/.github/workflows/tox.yml +++ b/.github/workflows/tox.yml @@ -238,9 +238,10 @@ jobs: token: ${{ secrets.CODECOV_TOKEN }} - if: ${{ (success() || failure()) && contains(matrix.coverage, 'github') && matrix.pytest == 'true' }} + name: add run info to coverage filename run: | - mv .coverage .coverage.${{ runner.os }}-${{ runner.arch }}-${{ matrix.toxenv }} ls -la . + mv .coverage .coverage.${{ runner.os }}-${{ runner.arch }}-${{ matrix.toxenv }} shell: sh - name: Upload coverage data to GitHub From 82addf68539a103d4fbf25cd227436c319198613 Mon Sep 17 00:00:00 2001 From: zacharyburnett Date: Wed, 26 Jun 2024 12:33:08 -0400 Subject: [PATCH 14/26] find .coverage --- .github/workflows/tox.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/tox.yml b/.github/workflows/tox.yml index e799cf3..95dc597 100644 --- a/.github/workflows/tox.yml +++ b/.github/workflows/tox.yml @@ -240,7 +240,7 @@ jobs: - if: ${{ (success() || failure()) && contains(matrix.coverage, 'github') && matrix.pytest == 'true' }} name: add run info to coverage filename run: | - ls -la . + find ~ -name .coverage mv .coverage .coverage.${{ runner.os }}-${{ runner.arch }}-${{ matrix.toxenv }} shell: sh From f20972d48dc50d66bb4ebdd523fba9ef5a189722 Mon Sep 17 00:00:00 2001 From: zacharyburnett Date: Wed, 26 Jun 2024 12:33:08 -0400 Subject: [PATCH 15/26] use `find` to find `.coverage` --- .github/workflows/tox.yml | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/.github/workflows/tox.yml b/.github/workflows/tox.yml index 95dc597..639974b 100644 --- a/.github/workflows/tox.yml +++ b/.github/workflows/tox.yml @@ -239,17 +239,15 @@ jobs: - if: ${{ (success() || failure()) && contains(matrix.coverage, 'github') && matrix.pytest == 'true' }} name: add run info to coverage filename - run: | - find ~ -name .coverage - mv .coverage .coverage.${{ runner.os }}-${{ runner.arch }}-${{ matrix.toxenv }} + run: mv $(find ~ -name .coverage) .coverage.${{ github.sha }}-${{ runner.os }}-${{ runner.arch }}-${{ matrix.toxenv }} shell: sh - name: Upload coverage data to GitHub if: ${{ (success() || failure()) && contains(matrix.coverage, 'github') && matrix.pytest == 'true' }} uses: actions/upload-artifact@v4 with: - name: .coverage.${{ runner.os }}-${{ runner.arch }}-${{ matrix.toxenv }} - path: .coverage.${{ runner.os }}-${{ runner.arch }}-${{ matrix.toxenv }} + name: .coverage.${{ github.sha }}-${{ runner.os }}-${{ runner.arch }}-${{ matrix.toxenv }} + path: .coverage.${{ github.sha }}-${{ runner.os }}-${{ runner.arch }}-${{ matrix.toxenv }} coverage: name: report coverage From 333092111a1abb0e8dde319af284cf82756a0d7e Mon Sep 17 00:00:00 2001 From: zacharyburnett Date: Thu, 27 Jun 2024 12:31:30 -0400 Subject: [PATCH 16/26] rename job to indicate that it is reporting overall coverage --- .github/workflows/tox.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/tox.yml b/.github/workflows/tox.yml index 639974b..2afe406 100644 --- a/.github/workflows/tox.yml +++ b/.github/workflows/tox.yml @@ -249,8 +249,8 @@ jobs: name: .coverage.${{ github.sha }}-${{ runner.os }}-${{ runner.arch }}-${{ matrix.toxenv }} path: .coverage.${{ github.sha }}-${{ runner.os }}-${{ runner.arch }}-${{ matrix.toxenv }} - coverage: - name: report coverage + report_overall_test_coverage: + name: report overall test coverage needs: - tox runs-on: ubuntu-latest From 6c4dc8caf859fc39871b433a2cea3d42fcdfe268 Mon Sep 17 00:00:00 2001 From: zacharyburnett Date: Thu, 27 Jun 2024 13:18:20 -0400 Subject: [PATCH 17/26] always run coverage report --- .github/workflows/tox.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/tox.yml b/.github/workflows/tox.yml index 2afe406..9972cec 100644 --- a/.github/workflows/tox.yml +++ b/.github/workflows/tox.yml @@ -250,9 +250,9 @@ jobs: path: .coverage.${{ github.sha }}-${{ runner.os }}-${{ runner.arch }}-${{ matrix.toxenv }} report_overall_test_coverage: + needs: [ tox ] + if: always() name: report overall test coverage - needs: - - tox runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 From d14c5a315a1edca792c3cf9cdb47d19983f87c02 Mon Sep 17 00:00:00 2001 From: Zach Burnett Date: Wed, 4 Dec 2024 08:57:40 -0500 Subject: [PATCH 18/26] search in current directory for coverage file Co-authored-by: Stuart Mumford --- .github/workflows/tox.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/tox.yml b/.github/workflows/tox.yml index 9972cec..b2b4f4c 100644 --- a/.github/workflows/tox.yml +++ b/.github/workflows/tox.yml @@ -239,7 +239,7 @@ jobs: - if: ${{ (success() || failure()) && contains(matrix.coverage, 'github') && matrix.pytest == 'true' }} name: add run info to coverage filename - run: mv $(find ~ -name .coverage) .coverage.${{ github.sha }}-${{ runner.os }}-${{ runner.arch }}-${{ matrix.toxenv }} + run: mv $(find . -name .coverage) .coverage.${{ github.sha }}-${{ runner.os }}-${{ runner.arch }}-${{ matrix.toxenv }} shell: sh - name: Upload coverage data to GitHub From 6c504dbd4d127a0f706d378db7c034c7d1a90972 Mon Sep 17 00:00:00 2001 From: Stuart Mumford Date: Wed, 4 Dec 2024 14:41:54 +0000 Subject: [PATCH 19/26] Test a different thing --- .github/workflows/tox.yml | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/.github/workflows/tox.yml b/.github/workflows/tox.yml index b2b4f4c..429be19 100644 --- a/.github/workflows/tox.yml +++ b/.github/workflows/tox.yml @@ -239,7 +239,9 @@ jobs: - if: ${{ (success() || failure()) && contains(matrix.coverage, 'github') && matrix.pytest == 'true' }} name: add run info to coverage filename - run: mv $(find . -name .coverage) .coverage.${{ github.sha }}-${{ runner.os }}-${{ runner.arch }}-${{ matrix.toxenv }} + run: | + find ${{GITHUB_WORKSPACE}} -name .coverage + mv $(find ${{GITHUB_WORKSPACE}} -name .coverage) .coverage.${{ github.sha }}-${{ runner.os }}-${{ runner.arch }}-${{ matrix.toxenv }} shell: sh - name: Upload coverage data to GitHub From 7374fa00e8bdf07dd5e058ba569baee34ccab6d4 Mon Sep 17 00:00:00 2001 From: Stuart Mumford Date: Wed, 4 Dec 2024 14:44:06 +0000 Subject: [PATCH 20/26] Apply suggestions from code review --- .github/workflows/tox.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/tox.yml b/.github/workflows/tox.yml index 429be19..32e59a9 100644 --- a/.github/workflows/tox.yml +++ b/.github/workflows/tox.yml @@ -240,8 +240,8 @@ jobs: - if: ${{ (success() || failure()) && contains(matrix.coverage, 'github') && matrix.pytest == 'true' }} name: add run info to coverage filename run: | - find ${{GITHUB_WORKSPACE}} -name .coverage - mv $(find ${{GITHUB_WORKSPACE}} -name .coverage) .coverage.${{ github.sha }}-${{ runner.os }}-${{ runner.arch }}-${{ matrix.toxenv }} + find ${{ github.workspace }} -name .coverage + mv $(find ${{ github.workspace }} -name .coverage) .coverage.${{ github.sha }}-${{ runner.os }}-${{ runner.arch }}-${{ matrix.toxenv }} shell: sh - name: Upload coverage data to GitHub From 77e673aabccc9c3da1a0092a7f973c8dd527f0d3 Mon Sep 17 00:00:00 2001 From: Stuart Mumford Date: Wed, 4 Dec 2024 15:08:43 +0000 Subject: [PATCH 21/26] Update .github/workflows/tox.yml --- .github/workflows/tox.yml | 9 +-------- 1 file changed, 1 insertion(+), 8 deletions(-) diff --git a/.github/workflows/tox.yml b/.github/workflows/tox.yml index 32e59a9..5ccd205 100644 --- a/.github/workflows/tox.yml +++ b/.github/workflows/tox.yml @@ -237,19 +237,12 @@ jobs: with: token: ${{ secrets.CODECOV_TOKEN }} - - if: ${{ (success() || failure()) && contains(matrix.coverage, 'github') && matrix.pytest == 'true' }} - name: add run info to coverage filename - run: | - find ${{ github.workspace }} -name .coverage - mv $(find ${{ github.workspace }} -name .coverage) .coverage.${{ github.sha }}-${{ runner.os }}-${{ runner.arch }}-${{ matrix.toxenv }} - shell: sh - - name: Upload coverage data to GitHub if: ${{ (success() || failure()) && contains(matrix.coverage, 'github') && matrix.pytest == 'true' }} uses: actions/upload-artifact@v4 with: name: .coverage.${{ github.sha }}-${{ runner.os }}-${{ runner.arch }}-${{ matrix.toxenv }} - path: .coverage.${{ github.sha }}-${{ runner.os }}-${{ runner.arch }}-${{ matrix.toxenv }} + path: **/.coverage report_overall_test_coverage: needs: [ tox ] From 758a58dd7098debd2870b0c3c9a4922d21506572 Mon Sep 17 00:00:00 2001 From: Stuart Mumford Date: Wed, 4 Dec 2024 15:11:35 +0000 Subject: [PATCH 22/26] Update .github/workflows/tox.yml --- .github/workflows/tox.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/tox.yml b/.github/workflows/tox.yml index 5ccd205..b64b612 100644 --- a/.github/workflows/tox.yml +++ b/.github/workflows/tox.yml @@ -242,7 +242,7 @@ jobs: uses: actions/upload-artifact@v4 with: name: .coverage.${{ github.sha }}-${{ runner.os }}-${{ runner.arch }}-${{ matrix.toxenv }} - path: **/.coverage + path: "**/.coverage" report_overall_test_coverage: needs: [ tox ] From d86a14b4825d975e933a98345f781a346b3bbd11 Mon Sep 17 00:00:00 2001 From: Stuart Mumford Date: Wed, 4 Dec 2024 15:21:50 +0000 Subject: [PATCH 23/26] Update .github/workflows/tox.yml --- .github/workflows/tox.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/tox.yml b/.github/workflows/tox.yml index b64b612..726d36a 100644 --- a/.github/workflows/tox.yml +++ b/.github/workflows/tox.yml @@ -242,7 +242,7 @@ jobs: uses: actions/upload-artifact@v4 with: name: .coverage.${{ github.sha }}-${{ runner.os }}-${{ runner.arch }}-${{ matrix.toxenv }} - path: "**/.coverage" + path: "${{ github.workspace }}/**/.coverage" report_overall_test_coverage: needs: [ tox ] From ce2cffe7b99c504481bd64ad03395c3a91e2b7aa Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Cl=C3=A9ment=20Robert?= Date: Mon, 10 Nov 2025 14:21:14 +0100 Subject: [PATCH 24/26] Fixup PR gh-207 --- .github/workflows/test_tox.yml | 9 +++++++++ .github/workflows/tox.yml | 28 +++++++++++++++++----------- pyproject.toml | 4 ++++ tox.ini | 5 +++++ 4 files changed, 35 insertions(+), 11 deletions(-) diff --git a/.github/workflows/test_tox.yml b/.github/workflows/test_tox.yml index f72df03..d28f47a 100644 --- a/.github/workflows/test_tox.yml +++ b/.github/workflows/test_tox.yml @@ -158,6 +158,15 @@ jobs: a/ cache-key: cache-${{ github.run_id }} + test_coverage_github: + uses: ./.github/workflows/tox.yml + with: + pytest: true + coverage: github + envs: | + - linux: py313-covcheck + - linux: py314-covcheck + test_artifact_upload: uses: ./.github/workflows/tox.yml with: diff --git a/.github/workflows/tox.yml b/.github/workflows/tox.yml index b74bc17..2e47c26 100644 --- a/.github/workflows/tox.yml +++ b/.github/workflows/tox.yml @@ -219,30 +219,33 @@ jobs: - run: python -m tox -e ${{ matrix.toxenv }} ${{ matrix.toxargs }} -- ${{ matrix.pytest_flag }} ${{ matrix.posargs }} - - if: ${{ (success() || failure()) && matrix.artifact-path != '' }} + - if: ${{ !cancelled() && matrix.artifact-path != '' }} uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0 with: name: ${{ matrix.artifact-name }} path: ${{ matrix.artifact-path }} - - if: ${{ (success() || failure()) && matrix.pytest-results-summary == 'true' && matrix.pytest == 'true' }} + - if: ${{ !cancelled() && matrix.pytest-results-summary == 'true' && matrix.pytest == 'true' }} uses: test-summary/action@31493c76ec9e7aa675f1585d3ed6f1da69269a86 # v2.4 with: paths: "**/results.xml" - name: Upload to Codecov # Even if tox fails, upload coverage - if: ${{ (success() || failure()) && contains(matrix.coverage, 'codecov') && matrix.pytest == 'true' }} + if: ${{ !cancelled() && contains(matrix.coverage, 'codecov') && matrix.pytest == 'true' }} uses: codecov/codecov-action@5a1091511ad55cbe89839c7260b706298ca349f7 # v5.5.1 with: token: ${{ secrets.CODECOV_TOKEN }} - name: Upload coverage data to GitHub - if: ${{ (success() || failure()) && contains(matrix.coverage, 'github') && matrix.pytest == 'true' }} - uses: actions/upload-artifact@v4 + if: ${{ !cancelled() && contains(matrix.coverage, 'github') && matrix.pytest == 'true' }} + uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0 with: name: .coverage.${{ github.sha }}-${{ runner.os }}-${{ runner.arch }}-${{ matrix.toxenv }} - path: "${{ github.workspace }}/**/.coverage" + path: "${{ github.workspace }}/**/.coverage*" + if-no-files-found: error + include-hidden-files: true + report_overall_test_coverage: needs: [ tox ] @@ -250,12 +253,12 @@ jobs: name: report overall test coverage runs-on: ubuntu-latest steps: - - uses: actions/checkout@v4 + - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0 with: lfs: true submodules: ${{ inputs.submodules }} ref: ${{ inputs.checkout_ref }} - - uses: actions/download-artifact@v4 + - uses: actions/download-artifact@018cc2cf5baa6db3ef3c5f8a56943fffe632ef53 # v6.0.0 with: pattern: .coverage.* merge-multiple: true @@ -264,17 +267,20 @@ jobs: [ "$(ls -A .coverage*)" ] && exit 0 || exit 1 continue-on-error: true - if: steps.check_downloaded_files.outcome == 'success' - uses: actions/setup-python@v5 + uses: actions/setup-python@e797f83bcb11b83ae66e0230d6156d7c80228e7c # v6.0.0 with: python-version: "3.12" - if: steps.check_downloaded_files.outcome == 'success' name: generate coverage report run: | - python -Im pip install --upgrade coverage[toml] + python -Im pip install 'pip>=25.1' + python -Im pip install --group covcheck python -Im coverage combine python -Im coverage report -i -m --format=markdown >> $GITHUB_STEP_SUMMARY - if: steps.check_downloaded_files.outcome == 'success' - uses: actions/upload-artifact@v4 + uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0 with: name: .coverage path: .coverage + if-no-files-found: error + include-hidden-files: true diff --git a/pyproject.toml b/pyproject.toml index 5dda3f1..e06ccbe 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -26,6 +26,10 @@ concurrency = [ "pytest-repeat>=0.9.3", "pytest-run-parallel>=0.4.4", ] +covcheck = [ + "coverage[toml] ; python_version < '3.11'", + "coverage>=7.11.3", +] test = [ "hypothesis>=6.113.0", "pytest>=8.3.5", diff --git a/tox.ini b/tox.ini index bfb2569..1e52eb7 100644 --- a/tox.ini +++ b/tox.ini @@ -7,6 +7,7 @@ envlist = py{,py}3{10,13}-python_version libraries cache-{setup,verify} + covcheck [testenv] allowlist_externals = @@ -17,6 +18,9 @@ allowlist_externals = bash rolldice which +dependency_groups = + covcheck: covcheck + covcheck: test skip_install = true passenv = MY_VAR commands = @@ -48,6 +52,7 @@ commands = artifact-upload: bash -c "echo 'hello world' > test.txt" # Verify that freethreaded builds are using freethreaded interpreter py313t: python -c "import sys; assert 'free-threading' in sys.version" + covcheck: coverage run --parallel-mode -m pytest --pyargs test_package {posargs} [testenv:pep8] description = verify pep8 From 0fe63581546436a05a7effd7f8f245543c1aedb1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Cl=C3=A9ment=20Robert?= Date: Wed, 12 Nov 2025 18:31:57 +0100 Subject: [PATCH 25/26] restore assumption that pytest-cov is ubuquitous --- pyproject.toml | 1 + tox.ini | 2 +- 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index e06ccbe..aa6ac86 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -29,6 +29,7 @@ concurrency = [ covcheck = [ "coverage[toml] ; python_version < '3.11'", "coverage>=7.11.3", + "pytest-cov>=7.0.0", ] test = [ "hypothesis>=6.113.0", diff --git a/tox.ini b/tox.ini index 1e52eb7..15986f5 100644 --- a/tox.ini +++ b/tox.ini @@ -52,7 +52,7 @@ commands = artifact-upload: bash -c "echo 'hello world' > test.txt" # Verify that freethreaded builds are using freethreaded interpreter py313t: python -c "import sys; assert 'free-threading' in sys.version" - covcheck: coverage run --parallel-mode -m pytest --pyargs test_package {posargs} + covcheck: pytest --pyargs test_package {posargs} [testenv:pep8] description = verify pep8 From 3f7a04eea679e37f1763547d165a07f2d3a3551b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Cl=C3=A9ment=20Robert?= Date: Thu, 13 Nov 2025 06:49:10 +0100 Subject: [PATCH 26/26] Fix PR 207 (for real) --- .github/workflows/test_tox.yml | 1 - .github/workflows/tox.yml | 30 +++++++++++++----------------- tools/tox_matrix.py | 2 -- tox.ini | 2 +- 4 files changed, 14 insertions(+), 21 deletions(-) diff --git a/.github/workflows/test_tox.yml b/.github/workflows/test_tox.yml index d28f47a..abf94b5 100644 --- a/.github/workflows/test_tox.yml +++ b/.github/workflows/test_tox.yml @@ -161,7 +161,6 @@ jobs: test_coverage_github: uses: ./.github/workflows/tox.yml with: - pytest: true coverage: github envs: | - linux: py313-covcheck diff --git a/.github/workflows/tox.yml b/.github/workflows/tox.yml index 2e47c26..7870ceb 100644 --- a/.github/workflows/tox.yml +++ b/.github/workflows/tox.yml @@ -123,7 +123,7 @@ jobs: python-version: '3.12' - run: echo $TOX_MATRIX_SCRIPT | base64 --decode > tox_matrix.py env: - TOX_MATRIX_SCRIPT: # /// script
# requires-python = "==3.12"
# dependencies = [
#     "click==8.2.1",
#     "packaging==25.0",
#     "pyyaml==6.0.2",
# ]
# ///
import json
import os
import re

import click
import yaml
from packaging.version import InvalidVersion, Version


@click.command()
@click.option("--envs", default="")
@click.option("--libraries", default="")
@click.option("--posargs", default="")
@click.option("--toxdeps", default="")
@click.option("--toxargs", default="")
@click.option("--pytest", default="true")
@click.option("--pytest-results-summary", default="false")
@click.option("--coverage", default="")
@click.option("--conda", default="auto")
@click.option("--setenv", default="")
@click.option("--display", default="false")
@click.option("--cache-path", default="")
@click.option("--cache-key", default="")
@click.option("--cache-restore-keys", default="")
@click.option("--artifact-path", default="")
@click.option("--runs-on", default="")
@click.option("--default-python", default="")
@click.option("--timeout-minutes", default="360")
def load_tox_targets(
    envs,
    libraries,
    posargs,
    toxdeps,
    toxargs,
    pytest,
    pytest_results_summary,
    coverage,
    conda,
    setenv,
    display,
    cache_path,
    cache_key,
    cache_restore_keys,
    artifact_path,
    runs_on,
    default_python,
    timeout_minutes,
):
    """Script to load tox targets for GitHub Actions workflow."""
    # Load envs config
    envs = yaml.load(envs, Loader=yaml.BaseLoader)
    print(json.dumps(envs, indent=2))

    # Load global libraries config
    global_libraries = {
        "brew": [],
        "brew-cask": [],
        "apt": [],
        "choco": [],
    }
    libraries = yaml.load(libraries, Loader=yaml.BaseLoader)
    if libraries is not None:
        global_libraries.update(libraries)
    print(json.dumps(global_libraries, indent=2))

    # Default images to use for runners
    default_runs_on = {
        "linux": "ubuntu-latest",
        "macos": "macos-latest",
        "windows": "windows-latest",
    }
    custom_runs_on = yaml.load(runs_on, Loader=yaml.BaseLoader)
    if isinstance(custom_runs_on, dict):
        default_runs_on.update(custom_runs_on)
    print(json.dumps(default_runs_on, indent=2))

    # Default string parameters which can be overwritten by each env
    string_parameters = {
        "posargs": posargs,
        "toxdeps": toxdeps,
        "toxargs": toxargs,
        "pytest": pytest,
        "pytest-results-summary": pytest_results_summary,
        "coverage": coverage,
        "conda": conda,
        "setenv": setenv,
        "display": display,
        "cache-path": cache_path,
        "cache-key": cache_key,
        "cache-restore-keys": cache_restore_keys,
        "artifact-path": artifact_path,
        "timeout-minutes": timeout_minutes,
    }

    # Create matrix
    matrix = {"include": []}
    for env in envs:
        matrix["include"].append(
            get_matrix_item(
                env,
                global_libraries=global_libraries,
                global_string_parameters=string_parameters,
                runs_on=default_runs_on,
                default_python=default_python,
            )
        )

    # Output matrix
    print(json.dumps(matrix, indent=2))
    with open(os.environ["GITHUB_OUTPUT"], "a") as f:
        f.write(f"matrix={json.dumps(matrix)}\n")


def get_matrix_item(env, global_libraries, global_string_parameters, runs_on, default_python):
    # define spec for each matrix include (+ global_string_parameters)
    item = {
        "os": None,
        "toxenv": None,
        "python_version": None,
        "name": None,
        "pytest_flag": None,
        "libraries_brew": None,
        "libraries_brew_cask": None,
        "libraries_apt": None,
        "libraries_choco": None,
        "cache-path": None,
        "cache-key": None,
        "cache-restore-keys": None,
        "artifact-name": None,
        "artifact-path": None,
        "timeout-minutes": None,
    }
    for string_param, default in global_string_parameters.items():
        env_value = env.get(string_param)
        item[string_param] = default if env_value is None else env_value

    # set os and toxenv
    for k, v in runs_on.items():
        if k in env:
            platform = k
            item["os"] = env.get("runs-on", v)
            item["toxenv"] = env[k]
    assert item["os"] is not None and item["toxenv"] is not None

    # set python_version
    python_version = env.get("python-version")
    m = re.search("^py(2|3)([0-9]+t?)", item["toxenv"])
    if python_version is not None:
        item["python_version"] = python_version
    elif m is not None:
        major, minor = m.groups()
        item["python_version"] = f"{major}.{minor}"
    else:
        item["python_version"] = env.get("default_python") or default_python

    # if Python is <3.10 we can't use macos-latest which is arm64
    try:
        if Version(item["python_version"]) < Version("3.10") and item["os"] == "macos-latest":
            item["os"] = "macos-12"
    except InvalidVersion:
        # python_version might be for example 'pypy-3.10' which won't parse
        pass

    # set name
    item["name"] = env.get("name") or f"{item['toxenv']} ({item['os']})"

    # set artifact-name (replace invalid path characters)
    item["artifact-name"] = re.sub(r"[\\ /:<>|*?\"']", "-", item["name"])
    item["artifact-name"] = re.sub(r"-+", "-", item["artifact-name"])

    # set pytest_flag
    item["pytest_flag"] = ""
    sep = r"\\" if platform == "windows" else "/"
    if item["pytest"] == "true":
        if "codecov" in item.get("coverage", ""):
            item["pytest_flag"] += (
                rf"--cov --cov-report=xml:${{GITHUB_WORKSPACE}}{sep}coverage.xml "
            )
        elif "github" in item.get("coverage", ""):
            item["pytest_flag"] += "--cov "

        if item["pytest-results-summary"] == "true":
            item["pytest_flag"] += rf"--junitxml ${{GITHUB_WORKSPACE}}{sep}results.xml "

    # set libraries
    env_libraries = env.get("libraries")
    if isinstance(env_libraries, str) and len(env_libraries.strip()) == 0:
        env_libraries = {}  # no libraries requested for environment
    libraries = global_libraries if env_libraries is None else env_libraries
    for manager in ["brew", "brew_cask", "apt", "choco"]:
        item[f"libraries_{manager}"] = " ".join(libraries.get(manager, []))

    # set "auto" conda value
    if item["conda"] == "auto":
        item["conda"] = "true" if "conda" in item["toxenv"] else "false"

    # inject toxdeps for conda
    if item["conda"] == "true" and "tox-conda" not in item["toxdeps"].lower():
        item["toxdeps"] = ("tox-conda " + item["toxdeps"]).strip()

    # make timeout-minutes a number
    item["timeout-minutes"] = int(item["timeout-minutes"])

    # verify values
    assert item["pytest"] in {"true", "false"}
    assert item["conda"] in {"true", "false"}
    assert item["display"] in {"true", "false"}

    return item


if __name__ == "__main__":
    load_tox_targets()
 + TOX_MATRIX_SCRIPT: # /// script
# requires-python = "==3.12"
# dependencies = [
#     "click==8.2.1",
#     "packaging==25.0",
#     "pyyaml==6.0.2",
# ]
# ///
import json
import os
import re

import click
import yaml
from packaging.version import InvalidVersion, Version


@click.command()
@click.option("--envs", default="")
@click.option("--libraries", default="")
@click.option("--posargs", default="")
@click.option("--toxdeps", default="")
@click.option("--toxargs", default="")
@click.option("--pytest", default="true")
@click.option("--pytest-results-summary", default="false")
@click.option("--coverage", default="")
@click.option("--conda", default="auto")
@click.option("--setenv", default="")
@click.option("--display", default="false")
@click.option("--cache-path", default="")
@click.option("--cache-key", default="")
@click.option("--cache-restore-keys", default="")
@click.option("--artifact-path", default="")
@click.option("--runs-on", default="")
@click.option("--default-python", default="")
@click.option("--timeout-minutes", default="360")
def load_tox_targets(
    envs,
    libraries,
    posargs,
    toxdeps,
    toxargs,
    pytest,
    pytest_results_summary,
    coverage,
    conda,
    setenv,
    display,
    cache_path,
    cache_key,
    cache_restore_keys,
    artifact_path,
    runs_on,
    default_python,
    timeout_minutes,
):
    """Script to load tox targets for GitHub Actions workflow."""
    # Load envs config
    envs = yaml.load(envs, Loader=yaml.BaseLoader)
    print(json.dumps(envs, indent=2))

    # Load global libraries config
    global_libraries = {
        "brew": [],
        "brew-cask": [],
        "apt": [],
        "choco": [],
    }
    libraries = yaml.load(libraries, Loader=yaml.BaseLoader)
    if libraries is not None:
        global_libraries.update(libraries)
    print(json.dumps(global_libraries, indent=2))

    # Default images to use for runners
    default_runs_on = {
        "linux": "ubuntu-latest",
        "macos": "macos-latest",
        "windows": "windows-latest",
    }
    custom_runs_on = yaml.load(runs_on, Loader=yaml.BaseLoader)
    if isinstance(custom_runs_on, dict):
        default_runs_on.update(custom_runs_on)
    print(json.dumps(default_runs_on, indent=2))

    # Default string parameters which can be overwritten by each env
    string_parameters = {
        "posargs": posargs,
        "toxdeps": toxdeps,
        "toxargs": toxargs,
        "pytest": pytest,
        "pytest-results-summary": pytest_results_summary,
        "coverage": coverage,
        "conda": conda,
        "setenv": setenv,
        "display": display,
        "cache-path": cache_path,
        "cache-key": cache_key,
        "cache-restore-keys": cache_restore_keys,
        "artifact-path": artifact_path,
        "timeout-minutes": timeout_minutes,
    }

    # Create matrix
    matrix = {"include": []}
    for env in envs:
        matrix["include"].append(
            get_matrix_item(
                env,
                global_libraries=global_libraries,
                global_string_parameters=string_parameters,
                runs_on=default_runs_on,
                default_python=default_python,
            )
        )

    # Output matrix
    print(json.dumps(matrix, indent=2))
    with open(os.environ["GITHUB_OUTPUT"], "a") as f:
        f.write(f"matrix={json.dumps(matrix)}\n")


def get_matrix_item(env, global_libraries, global_string_parameters, runs_on, default_python):
    # define spec for each matrix include (+ global_string_parameters)
    item = {
        "os": None,
        "toxenv": None,
        "python_version": None,
        "name": None,
        "pytest_flag": None,
        "libraries_brew": None,
        "libraries_brew_cask": None,
        "libraries_apt": None,
        "libraries_choco": None,
        "cache-path": None,
        "cache-key": None,
        "cache-restore-keys": None,
        "artifact-name": None,
        "artifact-path": None,
        "timeout-minutes": None,
    }
    for string_param, default in global_string_parameters.items():
        env_value = env.get(string_param)
        item[string_param] = default if env_value is None else env_value

    # set os and toxenv
    for k, v in runs_on.items():
        if k in env:
            platform = k
            item["os"] = env.get("runs-on", v)
            item["toxenv"] = env[k]
    assert item["os"] is not None and item["toxenv"] is not None

    # set python_version
    python_version = env.get("python-version")
    m = re.search("^py(2|3)([0-9]+t?)", item["toxenv"])
    if python_version is not None:
        item["python_version"] = python_version
    elif m is not None:
        major, minor = m.groups()
        item["python_version"] = f"{major}.{minor}"
    else:
        item["python_version"] = env.get("default_python") or default_python

    # if Python is <3.10 we can't use macos-latest which is arm64
    try:
        if Version(item["python_version"]) < Version("3.10") and item["os"] == "macos-latest":
            item["os"] = "macos-12"
    except InvalidVersion:
        # python_version might be for example 'pypy-3.10' which won't parse
        pass

    # set name
    item["name"] = env.get("name") or f"{item['toxenv']} ({item['os']})"

    # set artifact-name (replace invalid path characters)
    item["artifact-name"] = re.sub(r"[\\ /:<>|*?\"']", "-", item["name"])
    item["artifact-name"] = re.sub(r"-+", "-", item["artifact-name"])

    # set pytest_flag
    item["pytest_flag"] = ""
    sep = r"\\" if platform == "windows" else "/"
    if item["pytest"] == "true":
        if "codecov" in item.get("coverage", ""):
            item["pytest_flag"] += (
                rf"--cov --cov-report=xml:${{GITHUB_WORKSPACE}}{sep}coverage.xml "
            )

        if item["pytest-results-summary"] == "true":
            item["pytest_flag"] += rf"--junitxml ${{GITHUB_WORKSPACE}}{sep}results.xml "

    # set libraries
    env_libraries = env.get("libraries")
    if isinstance(env_libraries, str) and len(env_libraries.strip()) == 0:
        env_libraries = {}  # no libraries requested for environment
    libraries = global_libraries if env_libraries is None else env_libraries
    for manager in ["brew", "brew_cask", "apt", "choco"]:
        item[f"libraries_{manager}"] = " ".join(libraries.get(manager, []))

    # set "auto" conda value
    if item["conda"] == "auto":
        item["conda"] = "true" if "conda" in item["toxenv"] else "false"

    # inject toxdeps for conda
    if item["conda"] == "true" and "tox-conda" not in item["toxdeps"].lower():
        item["toxdeps"] = ("tox-conda " + item["toxdeps"]).strip()

    # make timeout-minutes a number
    item["timeout-minutes"] = int(item["timeout-minutes"])

    # verify values
    assert item["pytest"] in {"true", "false"}
    assert item["conda"] in {"true", "false"}
    assert item["display"] in {"true", "false"}

    return item


if __name__ == "__main__":
    load_tox_targets()
 - run: cat tox_matrix.py - id: set-outputs run: | @@ -146,6 +146,8 @@ jobs: name: ${{ matrix.name }} needs: [envs] runs-on: ${{ matrix.os }} + outputs: + coverage-gh: ${{ steps.upload-coverage-gh.outputs.artifact-id }} timeout-minutes: ${{ matrix.timeout-minutes }} strategy: fail-fast: ${{ inputs.fail-fast }} @@ -238,18 +240,18 @@ jobs: token: ${{ secrets.CODECOV_TOKEN }} - name: Upload coverage data to GitHub + id: upload-coverage-gh if: ${{ !cancelled() && contains(matrix.coverage, 'github') && matrix.pytest == 'true' }} uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0 with: - name: .coverage.${{ github.sha }}-${{ runner.os }}-${{ runner.arch }}-${{ matrix.toxenv }} - path: "${{ github.workspace }}/**/.coverage*" + name: coverage-data-${{ github.run_id }}-${{ runner.os }}-${{ runner.arch }}-${{ matrix.toxenv }} + path: .coverage.* if-no-files-found: error include-hidden-files: true - report_overall_test_coverage: needs: [ tox ] - if: always() + if: needs.tox.outputs.coverage-gh name: report overall test coverage runs-on: ubuntu-latest steps: @@ -260,27 +262,21 @@ jobs: ref: ${{ inputs.checkout_ref }} - uses: actions/download-artifact@018cc2cf5baa6db3ef3c5f8a56943fffe632ef53 # v6.0.0 with: - pattern: .coverage.* + pattern: coverage-data-${{ github.run_id }}-* merge-multiple: true - - id: check_downloaded_files - run: | - [ "$(ls -A .coverage*)" ] && exit 0 || exit 1 - continue-on-error: true - - if: steps.check_downloaded_files.outcome == 'success' - uses: actions/setup-python@e797f83bcb11b83ae66e0230d6156d7c80228e7c # v6.0.0 + + - uses: actions/setup-python@e797f83bcb11b83ae66e0230d6156d7c80228e7c # v6.0.0 with: python-version: "3.12" - - if: steps.check_downloaded_files.outcome == 'success' - name: generate coverage report + - name: generate coverage report run: | python -Im pip install 'pip>=25.1' python -Im pip install --group covcheck python -Im coverage combine python -Im coverage report -i -m --format=markdown >> $GITHUB_STEP_SUMMARY - - if: steps.check_downloaded_files.outcome == 'success' - uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0 + - uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0 with: - name: .coverage + name: coverage-report-${{ hashFiles('.coverage') }} path: .coverage if-no-files-found: error include-hidden-files: true diff --git a/tools/tox_matrix.py b/tools/tox_matrix.py index 67fdbc3..efcb8f6 100644 --- a/tools/tox_matrix.py +++ b/tools/tox_matrix.py @@ -184,8 +184,6 @@ def get_matrix_item(env, global_libraries, global_string_parameters, runs_on, de item["pytest_flag"] += ( rf"--cov --cov-report=xml:${{GITHUB_WORKSPACE}}{sep}coverage.xml " ) - elif "github" in item.get("coverage", ""): - item["pytest_flag"] += "--cov " if item["pytest-results-summary"] == "true": item["pytest_flag"] += rf"--junitxml ${{GITHUB_WORKSPACE}}{sep}results.xml " diff --git a/tox.ini b/tox.ini index 15986f5..1e52eb7 100644 --- a/tox.ini +++ b/tox.ini @@ -52,7 +52,7 @@ commands = artifact-upload: bash -c "echo 'hello world' > test.txt" # Verify that freethreaded builds are using freethreaded interpreter py313t: python -c "import sys; assert 'free-threading' in sys.version" - covcheck: pytest --pyargs test_package {posargs} + covcheck: coverage run --parallel-mode -m pytest --pyargs test_package {posargs} [testenv:pep8] description = verify pep8