diff --git a/.github/workflows/test_tox.yml b/.github/workflows/test_tox.yml index 5f13564..acdd90e 100644 --- a/.github/workflows/test_tox.yml +++ b/.github/workflows/test_tox.yml @@ -68,14 +68,13 @@ jobs: posargs: 'PyPy' pytest: false - test_supported_pythons: + test_python_version_glob: uses: ./.github/workflows/tox.yml with: envs: | - linux: pep8 - - linux: py3 - fill: true - fill_platforms: linux,macos + - linux: py3* + - macos: py31* pytest: false test_libraries: diff --git a/.github/workflows/tox.yml b/.github/workflows/tox.yml index 3b5a2ae..6dd1d91 100644 --- a/.github/workflows/tox.yml +++ b/.github/workflows/tox.yml @@ -7,21 +7,6 @@ on: description: Array of tox environments to test required: true type: string - fill: - description: Add an extra toxenv to the matrix for each current version of Python supported by the package - required: false - default: false - type: boolean - fill_platforms: - description: Platforms to iterate with fill - required: false - default: '' - type: string - fill_factors: - description: Tox factors to add to toxenvs added with `fill` - required: false - default: '' - type: string libraries: description: Additional packages to install required: false @@ -158,27 +143,24 @@ jobs: version: "0.10.6" enable-cache: false ignore-empty-workdir: "true" - - if: inputs.fill - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 + - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 with: ref: ${{ inputs.checkout_ref }} persist-credentials: false - - if: inputs.fill - run: echo $SUPPORTED_PYTHONS_SCRIPT | base64 --decode > supported_pythons.py - env: - SUPPORTED_PYTHONS_SCRIPT: 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 - - if: inputs.fill # zizmor: ignore[template-injection] - id: supported-pythons - run: uv run supported_pythons.py --package-source . ${{ inputs.fill_platforms != '' && format('--platforms {0}', inputs.fill_platforms) || '' }} ${{ inputs.fill_factors != '' && format('--factors {0}', inputs.fill_factors) || '' }} - shell: sh - 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 warnings

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("--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")
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,
):
    """Script to load tox targets for GitHub Actions workflow."""
    # 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["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,
        "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 "codecov" in item.get("coverage", ""):
            # Note that we don't include --cov here as if it's provided to pytest twice it breaks cov reporting.
            # Lots of users of this specify --cov in their tox.ini so it's been removed for backwards compatibility.
            # https://github.com/OpenAstronomy/github-actions-workflows/issues/383
            item["pytest_flag"] += (
                rf"--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, []))

    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


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",
#     "requests==2.32.5",
#     "tomli==2.4.0",
# ]
# ///
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 "codecov" in item.get("coverage", ""):
            # Note that we don't include --cov here as if it's provided to pytest twice it breaks cov reporting.
            # Lots of users of this specify --cov in their tox.ini so it's been removed for backwards compatibility.
            # https://github.com/OpenAstronomy/github-actions-workflows/issues/383
            item["pytest_flag"] += rf"--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, []))

    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, '*') + id: supported-pythons + uses: zacharyburnett/supported-pythons@1f2cfc00e73631d5ed7f01a6c7b0d2744ddc310c # 2.0.2 + with: + package: ${{ job.workflow_repository }} + package-ref: ${{ job.workflow_sha }} - id: set-outputs run: | # zizmor: ignore[template-injection] uv run tox_matrix.py \ - --envs "${{ !inputs.fill && inputs.envs || format('{0}\n{1}', inputs.envs, steps.supported-pythons.outputs.envs) }}" \ + --envs "${{ inputs.envs }}" \ --libraries "${{ inputs.libraries }}" \ --posargs "${{ inputs.posargs }}" --toxdeps "${{ inputs.toxdeps }}" \ --toxargs "${{ inputs.toxargs }}" --pytest "${{ inputs.pytest }}" \ @@ -192,7 +174,8 @@ jobs: --artifact-include-hidden-files "${{ inputs.artifact-include-hidden-files }}" \ --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 }}" + --timeout-minutes "${{ inputs.timeout-minutes }}" \ + --supported-pythons '${{ contains(inputs.envs, '*') && steps.supported-pythons.outputs.versions || '["3"]' }}' shell: sh outputs: matrix: ${{ steps.set-outputs.outputs.matrix }} diff --git a/docs/source/tox.rst b/docs/source/tox.rst index 73e1340..25a3270 100644 --- a/docs/source/tox.rst +++ b/docs/source/tox.rst @@ -86,6 +86,13 @@ environment. If the Python version includes a ``t`` suffix, such as ``py313t``, then a free-threaded Python interpreter will be used. +Additionally, the Python version can include glob syntax (i.e. `py3*`) to expand into all supported versions of Python (respecting ``project.requires-python`` in ``pyproject.toml`` as conforming with PEP621). + +For example: +- ``py*`` for all supported versions of Python (from https://endoflife.date) +- ``py3*`` for all supported minor versions of Python 3 +- ``py31*`` for all supported versions of Python between ``3.10`` and ``3.20`` + libraries ^^^^^^^^^ @@ -544,71 +551,6 @@ same repository, or when using a non-standard project layout. envs: | - linux: py312 -fill -^^^^ - -Automatically add tox environments for each Python version currently supported -by your package. The supported versions are determined by reading the -``requires-python`` field from your package's ``pyproject.toml`` file -(conforming to PEP 621) and cross-referencing with currently maintained Python -versions from https://endoflife.date. - -Default is ``false``. - -.. code:: yaml - - uses: OpenAstronomy/github-actions-workflows/.github/workflows/tox.yml@v2 - with: - fill: true - envs: | - - linux: pep8 - pytest: false - -In the above example, if your package's ``pyproject.toml`` specifies -``requires-python = ">=3.10"``, and Python 3.10, 3.11, 3.12, and 3.13 are -currently maintained, the workflow will automatically add ``py310``, ``py311``, -``py312``, and ``py313`` environments on Linux in addition to the ``pep8`` -environment. - -fill_platforms -^^^^^^^^^^^^^^ - -Platforms to use when generating environments with ``fill``. This is a -comma-separated list of platforms. Default is ``linux`` only. - -.. code:: yaml - - uses: OpenAstronomy/github-actions-workflows/.github/workflows/tox.yml@v2 - with: - fill: true - fill_platforms: linux,macos,windows - envs: | - - linux: pep8 - pytest: false - -This will create tox environments for each supported Python version on all -three platforms. - -fill_factors -^^^^^^^^^^^^ - -Tox factors to add to the automatically generated environments from ``fill``. -This is a comma-separated list of factors. Default is none. - -.. code:: yaml - - uses: OpenAstronomy/github-actions-workflows/.github/workflows/tox.yml@v2 - with: - fill: true - fill_factors: test,cov - envs: | - - linux: pep8 - pytest: false - -If your package supports Python 3.11 and 3.12, this will generate environments -like ``py311-test-cov`` and ``py312-test-cov`` instead of just ``py311`` and -``py312``. - Secrets ~~~~~~~ diff --git a/tools/supported_pythons.py b/tools/supported_pythons.py deleted file mode 100644 index b01b5a2..0000000 --- a/tools/supported_pythons.py +++ /dev/null @@ -1,123 +0,0 @@ -# /// script -# requires-python = ">=3.12" -# dependencies = [ -# "click==8.2.1", -# "packaging==25.0", -# "requests==2.32.5", -# "tomli==2.4.0", -# ] -# /// -import os -import warnings -from pathlib import Path - -import click -import requests -import tomli -from packaging.specifiers import SpecifierSet -from packaging.version import Version - - -@click.command() -@click.option("--package-source", default=None) -@click.option("--factors", default=None) -@click.option("--no-eoas", is_flag=True, default=False) -@click.option("--platforms", default=None) -def supported_python_envs_block( - package_source: Path = None, - factors: list[str] = None, - no_eoas: bool = False, - platforms: list[str] = None, -): - """enumerate toxenvs for each Python version supported by package""" - - if platforms is None: - platforms = ["linux"] - elif isinstance(platforms, str): - platforms = platforms.split(",") - - toxenvs = supported_python_toxenvs(package_source, factors, no_eoas) - envs_block = "\\n".join( - f"- {platform}: {toxenv}" for platform in platforms for toxenv in toxenvs - ) - - print(envs_block) - with open(os.environ["GITHUB_OUTPUT"], "a") as f: - f.write(f"envs={envs_block}\n") - - -def supported_python_toxenvs( - package_source: Path = None, - factors: list[str] = None, - no_eoas: bool = False, -) -> list[str]: - if isinstance(factors, str): - factors = factors.split(",") - - return [ - f"py{str(python_version).replace('.', '')}{'-' + '-'.join(factors) if factors is not None and len(factors) > 0 else ''}" - for python_version in supported_pythons(package_source, no_eoas=no_eoas) - ] - - -def supported_pythons( - package_source: Path = None, - no_eoas: bool = False, -) -> list[Version]: - current_python_versions = current_pythons(no_eoas=no_eoas) - - if not package_source: - supported_versions = current_python_versions - else: - try: - pyproject_toml_filename = Path(package_source) / "pyproject.toml" - if pyproject_toml_filename.exists(): - with open(pyproject_toml_filename, "rb") as pyproject_toml_file: - pyproject_toml = tomli.load(pyproject_toml_file) - if "project" in pyproject_toml: - project_metadata = pyproject_toml["project"] - if "requires-python" in project_metadata: - python_version_requirements = SpecifierSet( - project_metadata["requires-python"] - ) - else: - raise KeyError( - "`project.requires-python` not found in `pyproject.toml`; ensure your package conforms to PEP621" - ) - else: - raise KeyError( - "`project` not found in `pyproject.toml`; ensure your package conforms to PEP621" - ) - else: - raise FileNotFoundError( - "could not find `pyproject.toml` in the provided package source; ensure your package conforms to PEP621" - ) - - supported_versions = [ - python_version - for python_version in current_python_versions - if python_version in python_version_requirements - ] - except (KeyError, TypeError, FileNotFoundError) as error: - warnings.warn(str(error)) - warnings.warn("falling back to current Python versions...") - supported_versions = current_python_versions - - return supported_versions - - -def current_pythons(no_eoas: bool = False) -> list[Version]: - url = "https://endoflife.date/api/v1/products/python" - response = requests.get("https://endoflife.date/api/v1/products/python") - if response.status_code == 200: - return [ - Version(python_version["name"]) - for python_version in response.json()["result"]["releases"] - if not python_version["isEoas" if no_eoas else "isEol"] - ] - else: - raise ValueError(f"request to {url} returned status code {response.status_code}") - - -if __name__ == "__main__": - supported_python_envs_block() diff --git a/tools/tox_matrix.py b/tools/tox_matrix.py index 9ceed1a..0aace64 100644 --- a/tools/tox_matrix.py +++ b/tools/tox_matrix.py @@ -2,16 +2,21 @@ # requires-python = "==3.12" # dependencies = [ # "click==8.2.1", +# "packaging==25.0", # "pyyaml==6.0.2", +# "requests==2.32.5", +# "tomli==2.4.0", # ] # /// import json import os import re import warnings +from copy import copy import click import yaml +from packaging.version import Version @click.command() @@ -36,6 +41,7 @@ @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, @@ -58,8 +64,15 @@ def load_tox_targets( 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)) @@ -111,16 +124,30 @@ 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_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: @@ -188,9 +215,7 @@ def get_matrix_item(env, global_libraries, global_string_parameters, runs_on, de # Note that we don't include --cov here as if it's provided to pytest twice it breaks cov reporting. # Lots of users of this specify --cov in their tox.ini so it's been removed for backwards compatibility. # https://github.com/OpenAstronomy/github-actions-workflows/issues/383 - item["pytest_flag"] += ( - rf"--cov-report=xml:${{GITHUB_WORKSPACE}}{sep}coverage.xml " - ) + item["pytest_flag"] += rf"--cov-report=xml:${{GITHUB_WORKSPACE}}{sep}coverage.xml " if item["pytest-results-summary"] == "true": item["pytest_flag"] += rf"--junitxml ${{GITHUB_WORKSPACE}}{sep}results.xml " @@ -225,5 +250,56 @@ def get_matrix_item(env, global_libraries, global_string_parameters, runs_on, de 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() diff --git a/update_scripts_in_yml.py b/update_scripts_in_yml.py index fcc8c39..ec45756 100755 --- a/update_scripts_in_yml.py +++ b/update_scripts_in_yml.py @@ -34,4 +34,3 @@ def base64_encode_into(script, yml_file, env_var): base64_encode_into('set_env.py', 'tox.yml', 'SET_ENV_SCRIPT') base64_encode_into('set_env.py', 'publish.yml', 'SET_ENV_SCRIPT') base64_encode_into('set_env.py', 'publish_pure_python.yml', 'SET_ENV_SCRIPT') -base64_encode_into('supported_pythons.py', 'tox.yml', 'SUPPORTED_PYTHONS_SCRIPT')