antsibull-nox 0.0.1__py3-none-any.whl → 0.2.0__py3-none-any.whl

antsibull_nox/interpret_config.py

@@ -0,0 +1,235 @@
+# Author: Felix Fontein <felix@fontein.de>
+# GNU General Public License v3.0+ (see LICENSES/GPL-3.0-or-later.txt or
+# https://www.gnu.org/licenses/gpl-3.0.txt)
+# SPDX-License-Identifier: GPL-3.0-or-later
+# SPDX-FileCopyrightText: 2025, Ansible Project
+
+"""
+Interpret config.
+"""
+
+from __future__ import annotations
+
+import typing as t
+
+from .ansible import AnsibleCoreVersion
+from .collection import CollectionSource, setup_collection_sources
+from .config import ActionGroup as ConfigActionGroup
+from .config import (
+    Config,
+    DevelLikeBranch,
+    Sessions,
+)
+from .sessions import (
+    ActionGroup,
+    add_all_ansible_test_sanity_test_sessions,
+    add_all_ansible_test_unit_test_sessions,
+    add_ansible_lint,
+    add_ansible_test_integration_sessions_default_container,
+    add_build_import_check,
+    add_docs_check,
+    add_extra_checks,
+    add_license_check,
+    add_lint_sessions,
+    add_matrix_generator,
+)
+from .utils import Version
+
+
+def _interpret_config(config: Config) -> None:
+    if config.collection_sources:
+        setup_collection_sources(
+            {
+                name: CollectionSource(name=name, source=source.source)
+                for name, source in config.collection_sources.items()
+            }
+        )
+
+
+def _convert_action_groups(
+    action_groups: list[ConfigActionGroup] | None,
+) -> list[ActionGroup] | None:
+    if action_groups is None:
+        return None
+    return [
+        ActionGroup(
+            name=action_group.name,
+            pattern=action_group.pattern,
+            doc_fragment=action_group.doc_fragment,
+            exclusions=action_group.exclusions,
+        )
+        for action_group in action_groups
+    ]
+
+
+def _convert_devel_like_branches(
+    devel_like_branches: list[DevelLikeBranch] | None,
+) -> list[tuple[str | None, str]] | None:
+    if devel_like_branches is None:
+        return None
+    return [(branch.repository, branch.branch) for branch in devel_like_branches]
+
+
+def _convert_except_versions(
+    except_versions: list[AnsibleCoreVersion] | None,
+) -> list[AnsibleCoreVersion | str] | None:
+    return t.cast(t.Optional[list[AnsibleCoreVersion | str]], except_versions)
+
+
+def _convert_core_python_versions(
+    core_python_versions: dict[AnsibleCoreVersion | str, list[Version]] | None,
+) -> dict[str | AnsibleCoreVersion, list[str | Version]] | None:
+    return t.cast(
+        t.Optional[dict[str | AnsibleCoreVersion, list[str | Version]]],
+        core_python_versions,
+    )
+
+
+def _add_sessions(sessions: Sessions) -> None:
+    if sessions.lint:
+        add_lint_sessions(
+            make_lint_default=sessions.lint.default,
+            extra_code_files=sessions.lint.extra_code_files,
+            run_isort=sessions.lint.run_isort,
+            isort_config=sessions.lint.isort_config,
+            isort_package=sessions.lint.isort_package,
+            run_black=sessions.lint.run_black,
+            run_black_modules=sessions.lint.run_black_modules,
+            black_config=sessions.lint.black_config,
+            black_package=sessions.lint.black_package,
+            run_flake8=sessions.lint.run_flake8,
+            flake8_config=sessions.lint.flake8_config,
+            flake8_package=sessions.lint.flake8_package,
+            run_pylint=sessions.lint.run_pylint,
+            pylint_rcfile=sessions.lint.pylint_rcfile,
+            pylint_modules_rcfile=sessions.lint.pylint_modules_rcfile,
+            pylint_package=sessions.lint.pylint_package,
+            pylint_ansible_core_package=sessions.lint.pylint_ansible_core_package,
+            pylint_extra_deps=sessions.lint.pylint_extra_deps,
+            run_yamllint=sessions.lint.run_yamllint,
+            yamllint_config=sessions.lint.yamllint_config,
+            yamllint_config_plugins=sessions.lint.yamllint_config_plugins,
+            yamllint_config_plugins_examples=sessions.lint.yamllint_config_plugins_examples,
+            yamllint_package=sessions.lint.yamllint_package,
+            run_mypy=sessions.lint.run_mypy,
+            mypy_config=sessions.lint.mypy_config,
+            mypy_package=sessions.lint.mypy_package,
+            mypy_ansible_core_package=sessions.lint.mypy_ansible_core_package,
+            mypy_extra_deps=sessions.lint.mypy_extra_deps,
+        )
+    if sessions.docs_check:
+        add_docs_check(
+            make_docs_check_default=sessions.docs_check.default,
+            antsibull_docs_package=sessions.docs_check.antsibull_docs_package,
+            ansible_core_package=sessions.docs_check.ansible_core_package,
+            validate_collection_refs=sessions.docs_check.validate_collection_refs,
+            extra_collections=sessions.docs_check.extra_collections,
+        )
+    if sessions.license_check:
+        add_license_check(
+            make_license_check_default=sessions.license_check.default,
+            run_reuse=sessions.license_check.run_reuse,
+            reuse_package=sessions.license_check.reuse_package,
+            run_license_check=sessions.license_check.run_license_check,
+            license_check_extra_ignore_paths=(
+                sessions.license_check.license_check_extra_ignore_paths
+            ),
+        )
+    if sessions.extra_checks:
+        add_extra_checks(
+            make_extra_checks_default=sessions.extra_checks.default,
+            run_no_unwanted_files=sessions.extra_checks.run_no_unwanted_files,
+            no_unwanted_files_module_extensions=(
+                sessions.extra_checks.no_unwanted_files_module_extensions
+            ),
+            no_unwanted_files_other_extensions=(
+                sessions.extra_checks.no_unwanted_files_other_extensions
+            ),
+            no_unwanted_files_yaml_extensions=(
+                sessions.extra_checks.no_unwanted_files_yaml_extensions
+            ),
+            no_unwanted_files_skip_paths=(
+                sessions.extra_checks.no_unwanted_files_skip_paths
+            ),
+            no_unwanted_files_skip_directories=(
+                sessions.extra_checks.no_unwanted_files_skip_directories
+            ),
+            no_unwanted_files_yaml_directories=(
+                sessions.extra_checks.no_unwanted_files_yaml_directories
+            ),
+            no_unwanted_files_allow_symlinks=(
+                sessions.extra_checks.no_unwanted_files_allow_symlinks
+            ),
+            run_action_groups=sessions.extra_checks.run_action_groups,
+            action_groups_config=_convert_action_groups(
+                sessions.extra_checks.action_groups_config
+            ),
+        )
+    if sessions.build_import_check:
+        add_build_import_check(
+            make_build_import_check_default=sessions.build_import_check.default,
+            ansible_core_package=sessions.build_import_check.ansible_core_package,
+            run_galaxy_importer=sessions.build_import_check.run_galaxy_importer,
+            galaxy_importer_package=sessions.build_import_check.galaxy_importer_package,
+            galaxy_importer_config_path=sessions.build_import_check.galaxy_importer_config_path,
+        )
+    if sessions.ansible_test_sanity:
+        add_all_ansible_test_sanity_test_sessions(
+            default=sessions.ansible_test_sanity.default,
+            include_devel=sessions.ansible_test_sanity.include_devel,
+            include_milestone=sessions.ansible_test_sanity.include_milestone,
+            add_devel_like_branches=_convert_devel_like_branches(
+                sessions.ansible_test_sanity.add_devel_like_branches
+            ),
+            min_version=sessions.ansible_test_sanity.min_version,
+            max_version=sessions.ansible_test_sanity.max_version,
+            except_versions=_convert_except_versions(
+                sessions.ansible_test_sanity.except_versions
+            ),
+        )
+    if sessions.ansible_test_units:
+        add_all_ansible_test_unit_test_sessions(
+            default=sessions.ansible_test_units.default,
+            include_devel=sessions.ansible_test_units.include_devel,
+            include_milestone=sessions.ansible_test_units.include_milestone,
+            add_devel_like_branches=_convert_devel_like_branches(
+                sessions.ansible_test_units.add_devel_like_branches
+            ),
+            min_version=sessions.ansible_test_units.min_version,
+            max_version=sessions.ansible_test_units.max_version,
+            except_versions=_convert_except_versions(
+                sessions.ansible_test_units.except_versions
+            ),
+        )
+    if sessions.ansible_test_integration_w_default_container:
+        cfg = sessions.ansible_test_integration_w_default_container
+        add_ansible_test_integration_sessions_default_container(
+            default=cfg.default,
+            include_devel=cfg.include_devel,
+            include_milestone=(cfg.include_milestone),
+            add_devel_like_branches=_convert_devel_like_branches(
+                cfg.add_devel_like_branches
+            ),
+            min_version=cfg.min_version,
+            max_version=cfg.max_version,
+            except_versions=_convert_except_versions(cfg.except_versions),
+            core_python_versions=_convert_core_python_versions(
+                cfg.core_python_versions
+            ),
+            controller_python_versions_only=cfg.controller_python_versions_only,
+        )
+    if sessions.ansible_lint:
+        add_ansible_lint(
+            make_ansible_lint_default=sessions.ansible_lint.default,
+            ansible_lint_package=sessions.ansible_lint.ansible_lint_package,
+            strict=sessions.ansible_lint.strict,
+        )
+    add_matrix_generator()
+
+
+def interpret_config(config: Config) -> None:
+    """
+    Interpret the config file's contents.
+    """
+    _interpret_config(config)
+    _add_sessions(config.sessions)

antsibull_nox/paths.py

@@ -0,0 +1,220 @@
+# Author: Felix Fontein <felix@fontein.de>
+# GNU General Public License v3.0+ (see LICENSES/GPL-3.0-or-later.txt or
+# https://www.gnu.org/licenses/gpl-3.0.txt)
+# SPDX-License-Identifier: GPL-3.0-or-later
+# SPDX-FileCopyrightText: 2025, Ansible Project
+
+"""
+Path utilities.
+"""
+
+from __future__ import annotations
+
+import atexit
+import functools
+import os
+import shutil
+import tempfile
+from pathlib import Path
+
+from antsibull_fileutils.copier import Copier, GitCopier
+from antsibull_fileutils.vcs import detect_vcs, list_git_files
+
+
+def find_data_directory() -> Path:
+    """
+    Retrieve the directory for antsibull_nox.data on disk.
+    """
+    return Path(__file__).parent / "data"
+
+
+def match_path(path: str, is_file: bool, paths: list[str]) -> bool:
+    """
+    Check whether a path (that is a file or not) matches a given list of paths.
+    """
+    for check in paths:
+        if check == path:
+            return True
+        if not is_file:
+            if not check.endswith("/"):
+                check += "/"
+            if path.startswith(check):
+                return True
+    return False
+
+
+def restrict_paths(paths: list[str], restrict: list[str]) -> list[str]:
+    """
+    Restrict a list of paths with a given set of restrictions.
+    """
+    result = []
+    for path in paths:
+        is_file = os.path.isfile(path)
+        if not is_file and not path.endswith("/"):
+            path += "/"
+        if not match_path(path, is_file, restrict):
+            if not is_file:
+                for check in restrict:
+                    if check.startswith(path) and os.path.exists(check):
+                        result.append(check)
+            continue
+        result.append(path)
+    return result
+
+
+def _scan_remove_paths(
+    path: str, remove: list[str], extensions: list[str] | None
+) -> list[str]:
+    result = []
+    for root, dirs, files in os.walk(path, topdown=True):
+        if not root.endswith("/"):
+            root += "/"
+        if match_path(root, False, remove):
+            continue
+        if all(not check.startswith(root) for check in remove):
+            dirs[:] = []
+            result.append(root)
+            continue
+        for file in files:
+            if extensions and os.path.splitext(file)[1] not in extensions:
+                continue
+            filepath = os.path.normpath(os.path.join(root, file))
+            if not match_path(filepath, True, remove):
+                result.append(filepath)
+        for directory in list(dirs):
+            if directory == "__pycache__":
+                continue
+            dirpath = os.path.normpath(os.path.join(root, directory))
+            if match_path(dirpath, False, remove):
+                dirs.remove(directory)
+                continue
+    return result
+
+
+def remove_paths(
+    paths: list[str], remove: list[str], extensions: list[str] | None
+) -> list[str]:
+    """
+    Restrict a list of paths by removing paths.
+
+    If ``extensions`` is specified, only files matching this extension
+    will be considered when files need to be explicitly enumerated.
+    """
+    result = []
+    for path in paths:
+        is_file = os.path.isfile(path)
+        if not is_file and not path.endswith("/"):
+            path += "/"
+        if match_path(path, is_file, remove):
+            continue
+        if not is_file and any(check.startswith(path) for check in remove):
+            result.extend(_scan_remove_paths(path, remove, extensions))
+            continue
+        result.append(path)
+    return result
+
+
+def filter_paths(
+    paths: list[str],
+    /,
+    remove: list[str] | None = None,
+    restrict: list[str] | None = None,
+    extensions: list[str] | None = None,
+) -> list[str]:
+    """
+    Modifies a list of paths by restricting to and/or removing paths.
+    """
+    if restrict:
+        paths = restrict_paths(paths, restrict)
+    if remove:
+        paths = remove_paths(paths, remove, extensions)
+    return [path for path in paths if os.path.exists(path)]
+
+
+@functools.cache
+def list_all_files() -> list[Path]:
+    """
+    List all files of interest in the repository.
+    """
+    directory = Path.cwd()
+    vcs = detect_vcs(directory)
+    if vcs == "git":
+        return [directory / path.decode("utf-8") for path in list_git_files(directory)]
+    result = []
+    for root, dirs, files in os.walk(directory, topdown=True):
+        root_path = Path(root)
+        for file in files:
+            result.append(root_path / file)
+        if root_path == directory and ".nox" in dirs:
+            dirs.remove(".nox")
+    return result
+
+
+def remove_path(path: Path) -> None:
+    """
+    Delete a path.
+    """
+    if not path.is_symlink() and path.is_dir():
+        shutil.rmtree(path)
+    elif path.exists():
+        path.unlink()
+
+
+def copy_collection(source: Path, destination: Path) -> None:
+    """
+    Copy a collection from source to destination.
+
+    Automatically detect supported VCSs and use their information to avoid
+    copying ignored files.
+    """
+    if destination.exists():
+        remove_path(destination)
+    vcs = detect_vcs(source)
+    copier = {
+        "none": Copier,
+        "git": GitCopier,
+    }.get(vcs, Copier)()
+    copier.copy(source, destination, exclude_root=[".nox", ".tox"])
+
+
+def create_temp_directory(basename: str) -> Path:
+    """
+    Create a temporary directory outside the nox tree.
+    """
+    directory = tempfile.mkdtemp(prefix=basename)
+    path = Path(directory)
+
+    def cleanup() -> None:
+        remove_path(path)
+
+    atexit.register(cleanup)
+    return path
+
+
+def copy_directory_tree_into(source: Path, destination: Path) -> None:
+    """
+    Copy the directory tree from ``source`` into the tree at ``destination``.
+
+    If ``destination`` does not yet exist, it will be created first.
+    """
+    if not source.is_dir():
+        return
+    destination.mkdir(parents=True, exist_ok=True)
+    for root, _, files in source.walk():
+        path = destination / root.relative_to(source)
+        path.mkdir(exist_ok=True)
+        for file in files:
+            dest = path / file
+            remove_path(dest)
+            shutil.copy2(root / file, dest, follow_symlinks=False)
+
+
+__all__ = [
+    "copy_collection",
+    "copy_directory_tree_into",
+    "create_temp_directory",
+    "filter_paths",
+    "find_data_directory",
+    "list_all_files",
+    "remove_path",
+]

antsibull_nox/python.py

@@ -0,0 +1,81 @@
+# Author: Felix Fontein <felix@fontein.de>
+# GNU General Public License v3.0+ (see LICENSES/GPL-3.0-or-later.txt or
+# https://www.gnu.org/licenses/gpl-3.0.txt)
+# SPDX-License-Identifier: GPL-3.0-or-later
+# SPDX-FileCopyrightText: 2025, Ansible Project
+
+"""
+Python version utilities.
+"""
+
+from __future__ import annotations
+
+import functools
+import shutil
+import subprocess
+from pathlib import Path
+
+from .utils import Version
+
+# The following contains Python version candidates
+_PYTHON_VERSIONS_TO_TRY: tuple[Version, ...] = tuple(
+    Version.parse(v)
+    for v in [
+        # Python 2:
+        "2.6",
+        "2.7",
+        # Python 3:
+        "3.5",
+        "3.6",
+        "3.7",
+        "3.8",
+        "3.9",
+        "3.10",
+        "3.11",
+        "3.12",
+        "3.13",
+        "3.14",
+        # "3.15",
+        # "3.16",
+    ]
+)
+
+
+@functools.cache
+def get_installed_python_versions() -> dict[Version, Path]:
+    """
+    Return a map of supported Python versions for which interpreters exist and are on the path,
+    mapped to an executable.
+    """
+    result = {}
+
+    # Look for pythonX.Y binaries
+    for candidate in _PYTHON_VERSIONS_TO_TRY:
+        if exe := shutil.which(f"python{candidate}"):
+            result[candidate] = Path(exe)
+
+    # Look for python, python2, python3 binaries and determine their version
+    for executable in ("python", "python2", "python3"):
+        exe = shutil.which(executable)
+        if exe:
+            script = "import platform; print('.'.join(platform.python_version().split('.')[:2]))"
+            exe_result = subprocess.run(
+                [exe, "-c", script],
+                check=False,
+                text=True,
+                capture_output=True,
+            )
+            if exe_result.returncode == 0 and exe_result.stdout:
+                try:
+                    version = Version.parse(exe_result.stdout.strip())
+                except (AttributeError, ValueError):
+                    continue
+                else:
+                    result.setdefault(version, Path(exe))
+
+    return result
+
+
+__all__ = [
+    "get_installed_python_versions",
+]