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..97ac14f 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,18 @@ 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
from pathlib import Path

import click
import requests
import tomli
import yaml
from packaging.specifiers import SpecifierSet
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")
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_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)

            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) -> 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.
    """

    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"
        )

    python_versions = get_supported_python_versions(package_source=".")

    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
    ]


def get_supported_python_versions(
    package_source: Path = None,
    no_eoas: bool = False,
) -> list[Version]:
    current_python_versions = get_current_python_versions(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 sorted(supported_versions)


def get_current_python_versions(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__":
    load_tox_targets()
 - run: cat tox_matrix.py - 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 }}" \ 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..ba82531 100644 --- a/tools/tox_matrix.py +++ b/tools/tox_matrix.py @@ -2,16 +2,25 @@ # 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 +from pathlib import Path import click +import requests +import tomli import yaml +from packaging.specifiers import SpecifierSet +from packaging.version import Version @click.command() @@ -111,16 +120,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) + + 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 +211,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 +246,115 @@ def get_matrix_item(env, global_libraries, global_string_parameters, runs_on, de return item +def expand_python_versions(toxenv: 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. + """ + + 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" + ) + + python_versions = get_supported_python_versions(package_source=".") + + 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 + ] + + +def get_supported_python_versions( + package_source: Path = None, + no_eoas: bool = False, +) -> list[Version]: + current_python_versions = get_current_python_versions(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 sorted(supported_versions) + + +def get_current_python_versions(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__": 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')