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

antsibull_nox/data_util.py

@@ -11,89 +11,12 @@ Utility code for scripts in data.
 from __future__ import annotations
 
 import json
-import sys
 import typing as t
 from pathlib import Path
 
 import nox
 
 
-def setup() -> tuple[list[str], dict[str, t.Any]]:
-    """
-    Fetch list of paths and potential extra configuration.
-
-    First thing to call in an extra sanity check script in data/.
-    """
-    if len(sys.argv) == 3 and sys.argv[1] == "--data":
-        # Preferred way: load information from JSON file
-        path = sys.argv[2]
-        try:
-            with open(path, "rb") as f:
-                data = json.load(f)
-        except Exception as exc:
-            raise ValueError(f"Error while reading JSON from {path}") from exc
-        try:
-            paths = get_list_of_strings(data, "paths")
-        except ValueError as exc:
-            raise ValueError(f"Invalid JSON content in {path}: {exc}") from exc
-        data.pop("paths")
-        return paths, data
-    if len(sys.argv) >= 2:
-        # It's also possible to pass a list of paths on the command line, to simplify
-        # testing these scripts.
-        return sys.argv[1:], {}
-    # Alternatively one can pass a list of files from stdin, for example by piping
-    # the output of 'git ls-files' into this script. This is also for testing these
-    # scripts.
-    return sys.stdin.read().splitlines(), {}
-
-
-def get_list_of_strings(
-    data: dict[str, t.Any],
-    key: str,
-    *,
-    default: list[str] | None = None,
-) -> list[str]:
-    """
-    Retrieves a list of strings from key ``key`` of the JSON object ``data``.
-
-    If ``default`` is set to a list, a missing key results in this value being returned.
-    """
-    sentinel = object()
-    value = data.get(key, sentinel)
-    if value is sentinel:
-        if default is not None:
-            return default
-        raise ValueError(f"{key!r} is not a present")
-    if not isinstance(value, list):
-        raise ValueError(f"{key!r} is not a list, but {type(key)}")
-    if not all(isinstance(entry, str) for entry in value):
-        raise ValueError(f"{key!r} is not a list of strings")
-    return t.cast(list[str], value)
-
-
-def get_bool(
-    data: dict[str, t.Any],
-    key: str,
-    *,
-    default: bool | None = None,
-) -> bool:
-    """
-    Retrieves a boolean from key ``key`` of the JSON object ``data``.
-
-    If ``default`` is set to a boolean, a missing key results in this value being returned.
-    """
-    sentinel = object()
-    value = data.get(key, sentinel)
-    if value is sentinel:
-        if default is not None:
-            return default
-        raise ValueError(f"{key!r} is not a present")
-    if not isinstance(value, bool):
-        raise ValueError(f"{key!r} is not a bool, but {type(key)}")
-    return value
-
-
 def prepare_data_script(
     session: nox.Session,
     *,

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

@@ -191,8 +191,27 @@ def create_temp_directory(basename: str) -> Path:
     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",

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",
+]