From 7809457f66b0b6c04a7c030ede51d39e83cd1bcd Mon Sep 17 00:00:00 2001 From: zacharyburnett Date: Mon, 8 Jun 2026 10:14:19 -0400 Subject: [PATCH] allow user to specify list of base Python versions, to bypass retrieving from https://endoflife.date --- .github/workflows/tox.yml | 17 +++++++++------ docs/source/tox.rst | 45 ++++++++++++++++++++++++++++++++++----- tools/tox_matrix.py | 17 +++++++++------ 3 files changed, 60 insertions(+), 19 deletions(-) diff --git a/.github/workflows/tox.yml b/.github/workflows/tox.yml index e0e1488d..33b0ec76 100644 --- a/.github/workflows/tox.yml +++ b/.github/workflows/tox.yml @@ -7,6 +7,11 @@ on: description: Array of tox environments to test required: true type: string + python-versions: + description: use these versions (i.e. `3.11 3.12 3.14`) for Python version glob expansion (`py*`), instead of retrieving active versions from https://endoflife.date + required: false + default: '' + type: string libraries: description: Additional packages to install required: false @@ -133,7 +138,6 @@ on: required: false jobs: - envs: name: Load tox environments runs-on: ubuntu-latest @@ -148,16 +152,16 @@ jobs: persist-credentials: false - 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 warnings
from copy import copy

import click
import yaml
from packaging.version import 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("--artifact-archive", default="true")
@click.option("--artifact-include-hidden-files", default="false")
@click.option("--artifact-if-no-files-found", default="warn")
@click.option("--runs-on", default="")
@click.option("--default-python", default="")
@click.option("--timeout-minutes", default="360")
@click.option("--supported-pythons", default='["3"]')
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,
    artifact_archive,
    artifact_include_hidden_files,
    artifact_if_no_files_found,
    runs_on,
    default_python,
    timeout_minutes,
    supported_pythons,
):
    """Script to load tox targets for GitHub Actions workflow."""

    if not supported_pythons:
        supported_pythons = ['3']
    elif isinstance(supported_pythons, str):
        supported_pythons = json.loads(supported_pythons)

    # Load envs config
    envs = yaml.load(envs.replace("\\n", "\n"), 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,
        "artifact-archive": artifact_archive,
        "artifact-include-hidden-files": artifact_include_hidden_files,
        "artifact-if-no-files-found": artifact_if_no_files_found,
        "timeout-minutes": timeout_minutes,
    }

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

        # check if we need to expand python versions from a glob (i.e. py*, py3*, py31*, etc.)
        toxenv = matrix_item["toxenv"]
        if toxenv.startswith("py") and "*" in toxenv.split("-")[0]:
            toxenvs = expand_python_versions(toxenv, python_versions=supported_pythons)

            for expanded_toxenv, python_version in toxenvs:
                expanded_matrix_item = copy(matrix_item)
                expanded_matrix_item["toxenv"] = expanded_toxenv
                expanded_matrix_item["name"] = expanded_matrix_item["name"].replace(
                    toxenv, expanded_toxenv
                )
                expanded_matrix_item["python_version"] = python_version
                matrix["include"].append(expanded_matrix_item)
        else:
            matrix["include"].append(matrix_item)

    # 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,
        "artifact-archive": None,
        "artifact-include-hidden-files": None,
        "artifact-if-no-files-found": 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":
        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, []))

    if item["conda"]:
        warnings.warn("`conda` parameter is deprecated")

        # 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


def expand_python_versions(toxenv: str, python_versions: list[Version | str]) -> list[(str, str)]:
    """
    expand `py3*` into `py311`, `py312`, `py313`, etc. based on currently-supported Python versions

    :param version_glob: can be `py*`, `py3*`, `py30*`, `py31*` etc.
    """

    python_versions = [Version(version) for version in python_versions]

    toxenv_factors = toxenv.split("-")
    py_version_glob = toxenv_factors[0]
    if not py_version_glob.startswith("py"):
        raise ValueError(
            f'input "{py_version_glob}" is not a Python version Tox factor (must start with `py`)'
        )

    if "*" not in py_version_glob:
        return [py_version_glob]

    if not py_version_glob.endswith("*"):
        raise NotImplementedError(
            "Python version glob must end with a `*`; suffixes such as `t` are not yet supported"
        )

    major_version = py_version_glob[2]
    if major_version != "*":
        python_versions = [
            python_version
            for python_version in python_versions
            if python_version.major == int(major_version)
        ]

        minor_version = py_version_glob[3:]
        if minor_version_specifier := minor_version.split("*")[0] != "*":
            minor_version_base = int(minor_version_specifier) * 10
            python_versions = [
                python_version
                for python_version in python_versions
                if minor_version_base <= python_version.minor < minor_version_base + 10
            ]

    return [
        (
            f"py{python_version.major}{python_version.minor}"
            + (f"-{'-'.join(toxenv_factors[1:])}" if len(toxenv_factors) > 1 else ""),
            str(python_version),
        )
        for python_version in python_versions
    ]


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 warnings
from copy import copy

import click
import yaml
from packaging.version import 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("--artifact-archive", default="true")
@click.option("--artifact-include-hidden-files", default="false")
@click.option("--artifact-if-no-files-found", default="warn")
@click.option("--runs-on", default="")
@click.option("--default-python", default="")
@click.option("--timeout-minutes", default="360")
@click.option("--python-versions", default='["3"]')
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,
    artifact_archive,
    artifact_include_hidden_files,
    artifact_if_no_files_found,
    runs_on,
    default_python,
    timeout_minutes,
    python_versions,
):
    """Script to load tox targets for GitHub Actions workflow."""

    if not python_versions:
        python_versions= ['3']
    elif isinstance(python_versions, str):
        try:
            python_versions= json.loads(python_versions)
        except json.decoder.JSONDecodeError:
            python_versions= python_versions.split()

    # Load envs config
    envs = yaml.load(envs.replace("\\n", "\n"), 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,
        "artifact-archive": artifact_archive,
        "artifact-include-hidden-files": artifact_include_hidden_files,
        "artifact-if-no-files-found": artifact_if_no_files_found,
        "timeout-minutes": timeout_minutes,
    }

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

        # check if we need to expand python versions from a glob (i.e. py*, py3*, py31*, etc.)
        toxenv = matrix_item["toxenv"]
        if toxenv.startswith("py") and "*" in toxenv.split("-")[0]:
            toxenvs = expand_python_versions(toxenv, python_versions=python_versions)

            for expanded_toxenv, python_version in toxenvs:
                expanded_matrix_item = copy(matrix_item)
                expanded_matrix_item["toxenv"] = expanded_toxenv
                expanded_matrix_item["name"] = expanded_matrix_item["name"].replace(
                    toxenv, expanded_toxenv
                )
                expanded_matrix_item["python_version"] = python_version
                matrix["include"].append(expanded_matrix_item)
        else:
            matrix["include"].append(matrix_item)

    # 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,
        "artifact-archive": None,
        "artifact-include-hidden-files": None,
        "artifact-if-no-files-found": 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":
        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, []))

    if item["conda"]:
        warnings.warn("`conda` parameter is deprecated")

        # 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


def expand_python_versions(toxenv: str, python_versions: list[Version | str]) -> list[(str, str)]:
    """
    expand `py3*` into `py311`, `py312`, `py313`, etc. based on currently-supported Python versions

    :param version_glob: can be `py*`, `py3*`, `py30*`, `py31*` etc.
    """

    python_versions = [Version(version) for version in python_versions]

    toxenv_factors = toxenv.split("-")
    py_version_glob = toxenv_factors[0]
    if not py_version_glob.startswith("py"):
        raise ValueError(
            f'input "{py_version_glob}" is not a Python version Tox factor (must start with `py`)'
        )

    if "*" not in py_version_glob:
        return [py_version_glob]

    if not py_version_glob.endswith("*"):
        raise NotImplementedError(
            "Python version glob must end with a `*`; suffixes such as `t` are not yet supported"
        )

    major_version = py_version_glob[2]
    if major_version != "*":
        python_versions = [
            python_version
            for python_version in python_versions
            if python_version.major == int(major_version)
        ]

        minor_version = py_version_glob[3:]
        if minor_version_specifier := minor_version.split("*")[0] != "*":
            minor_version_base = int(minor_version_specifier) * 10
            python_versions = [
                python_version
                for python_version in python_versions
                if minor_version_base <= python_version.minor < minor_version_base + 10
            ]

    return [
        (
            f"py{python_version.major}{python_version.minor}"
            + (f"-{'-'.join(toxenv_factors[1:])}" if len(toxenv_factors) > 1 else ""),
            str(python_version),
        )
        for python_version in python_versions
    ]


if __name__ == "__main__":
    load_tox_targets()
 - run: cat tox_matrix.py - - if: contains(inputs.envs, '*') + - if: inputs.python-versions == '' && contains(inputs.envs, '*') id: supported-pythons uses: OpenAstronomy/supported-pythons@83fea1cbcd1df5494f6846152992a553def0325b # 2.0.4 with: package: ${{ job.workflow_repository }} package-ref: ${{ job.workflow_sha }} - id: set-outputs - run: | # zizmor: ignore[template-injection] + run: | # zizmor: ignore[template-injection] uv run tox_matrix.py \ --envs "${{ inputs.envs }}" \ --libraries "${{ inputs.libraries }}" \ @@ -174,12 +178,11 @@ jobs: --artifact-if-no-files-found "${{ inputs.artifact-if-no-files-found }}" \ --runs-on "${{ inputs.runs-on }}" --default-python "${{ inputs.default_python }}" \ --timeout-minutes "${{ inputs.timeout-minutes }}" \ - --supported-pythons '${{ contains(inputs.envs, '*') && steps.supported-pythons.outputs.versions || '["3"]' }}' + --python-versions '${{ inputs.python-versions || contains(inputs.envs, '*') && steps.supported-pythons.outputs.versions || '["3"]' }}' shell: sh outputs: matrix: ${{ steps.set-outputs.outputs.matrix }} - tox: name: ${{ matrix.name }} needs: [envs] @@ -322,7 +325,7 @@ jobs: coverage-gh: ${{ steps.upload-coverage-gh.outputs.artifact-id }} report_overall_test_coverage: - needs: [ tox ] + needs: [tox] if: needs.tox.outputs.coverage-gh name: report overall test coverage runs-on: ubuntu-latest diff --git a/docs/source/tox.rst b/docs/source/tox.rst index f29e8317..1f3d1164 100644 --- a/docs/source/tox.rst +++ b/docs/source/tox.rst @@ -89,14 +89,49 @@ a free-threaded Python interpreter will be used. Python Version Globs (``py*``) """""""""""""""""""""""""""""" -You can use glob syntax for the Python version (i.e. ``py3*``) to expand into all active (not end-of-life) minor versions of Python retrieved from https://endoflife.date +You can use glob syntax for the Python version (i.e. ``py3*``) +to multiply a single env by ``python_versions`` (see below), +preserving Tox factors, test platform, and other env parameters: Additionally, if your project has a ``pyproject.toml`` with a ``project.requires-python`` the Python versions will be constrained to respect that. -For example: -- ``py*`` for all active minor versions of Python supported by your package -- ``py3*`` for all active minor versions of Python 3 supported by your package -- ``py31*`` for all active minor versions of Python between ``3.10`` and ``3.19`` supported by your package +For example with ``python_versions: 3.9 3.10 3.11 3.12 3.13 3.14`` and ``project.requires-python = ">=3.9,<3.14"``, + +.. code-block:: yaml + + uses: OpenAstronomy/github-actions-workflows/.github/workflows/tox.yml@v2 + with: + envs: | + - linux: check-style + - linux: py3* + - macos: py31*-cov-xdist + +expands into the following: + +.. code:: yaml + + uses: OpenAstronomy/github-actions-workflows/.github/workflows/tox.yml@v2 + with: + envs: | + - linux: check-style + - linux: py39 + - linux: py310 + - linux: py311 + - linux: py312 + - linux: py313 + - linux: py314 + - macos: py310-cov-xdist + - macos: py311-cov-xdist + - macos: py312-cov-xdist + - macos: py313-cov-xdist + - macos: py314-cov-xdist + +python_versions +^^^^^^^^^^^^^^^ + +Space-separated list of Python versions, i.e. ``3.11 3.12 3.14``, +used to expand Python version globs (see above). +Defaults to all active (not end-of-life) Python versions from https://endoflife.date libraries ^^^^^^^^^ diff --git a/tools/tox_matrix.py b/tools/tox_matrix.py index 441227e2..81fbf47e 100644 --- a/tools/tox_matrix.py +++ b/tools/tox_matrix.py @@ -39,7 +39,7 @@ @click.option("--runs-on", default="") @click.option("--default-python", default="") @click.option("--timeout-minutes", default="360") -@click.option("--supported-pythons", default='["3"]') +@click.option("--python-versions", default='["3"]') def load_tox_targets( envs, libraries, @@ -62,14 +62,17 @@ def load_tox_targets( runs_on, default_python, timeout_minutes, - supported_pythons, + python_versions, ): """Script to load tox targets for GitHub Actions workflow.""" - if not supported_pythons: - supported_pythons = ['3'] - elif isinstance(supported_pythons, str): - supported_pythons = json.loads(supported_pythons) + if not python_versions: + python_versions= ['3'] + elif isinstance(python_versions, str): + try: + python_versions= json.loads(python_versions) + except json.decoder.JSONDecodeError: + python_versions= python_versions.split() # Load envs config envs = yaml.load(envs.replace("\\n", "\n"), Loader=yaml.BaseLoader) @@ -133,7 +136,7 @@ def load_tox_targets( # check if we need to expand python versions from a glob (i.e. py*, py3*, py31*, etc.) toxenv = matrix_item["toxenv"] if toxenv.startswith("py") and "*" in toxenv.split("-")[0]: - toxenvs = expand_python_versions(toxenv, python_versions=supported_pythons) + toxenvs = expand_python_versions(toxenv, python_versions=python_versions) for expanded_toxenv, python_version in toxenvs: expanded_matrix_item = copy(matrix_item)