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

antsibull_nox/sessions.py

@@ -10,13 +10,37 @@ Create nox sessions.
 
 from __future__ import annotations
 
-import contextlib
 import os
 import shlex
+import subprocess
+import sys
+import typing as t
+from dataclasses import asdict, dataclass
+from pathlib import Path
 
 import nox
 
-IN_CI = "GITHUB_ACTIONS" in os.environ
+from .collection import (
+    CollectionData,
+    force_collection_version,
+    load_collection_data_from_disk,
+    setup_collections,
+    setup_current_tree,
+)
+from .data_util import prepare_data_script
+from .paths import (
+    copy_collection,
+    create_temp_directory,
+    filter_paths,
+    find_data_directory,
+    list_all_files,
+    remove_path,
+)
+
+# https://docs.github.com/en/actions/writing-workflows/choosing-what-your-workflow-does/store-information-in-variables#default-environment-variables
+# https://docs.gitlab.com/ci/variables/predefined_variables/#predefined-variables
+# https://docs.travis-ci.com/user/environment-variables/#default-environment-variables
+IN_CI = os.environ.get("CI") == "true"
 ALLOW_EDITABLE = os.environ.get("ALLOW_EDITABLE", str(not IN_CI)).lower() in (
     "1",
     "true",
@@ -52,132 +76,130 @@ def install(session: nox.Session, *args: str, editable: bool = False, **kwargs):
     session.install(*args, "-U", **kwargs)
 
 
-@contextlib.contextmanager
-def ansible_collection_root():
+@dataclass
+class CollectionSetup:
     """
-    Context manager that changes to the root directory and yields the path of
-    the root directory and the prefix to the current working directory from the root.
+    Information on the setup collections.
     """
-    cwd = os.getcwd()
-    root = os.path.normpath(os.path.join(cwd, "..", "..", ".."))
-    try:
-        os.chdir(root)
-        yield root, os.path.relpath(cwd, root)
-    finally:
-        os.chdir(cwd)
 
+    # The path of the ansible_collections directory where all dependent collections
+    # are installed. Is currently identical to current_root, but that might change
+    # or depend on options in the future.
+    collections_root: Path
 
-def prefix_paths(paths: list[str], /, prefix: str) -> list[str]:
-    """
-    Prefix paths with the given prefix.
-    """
-    return [os.path.join(prefix, path) for path in paths]
+    # The directory in which ansible_collections can be found, as well as
+    # ansible_collections/<namespace>/<name> points to a copy of the current collection.
+    current_place: Path
 
+    # The path of the ansible_collections directory that contains the current collection.
+    # The following is always true:
+    #   current_root == current_place / "ansible_collections"
+    current_root: Path
 
-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.
+    # Data on the current collection (as in the repository).
+    current_collection: CollectionData
 
-    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]:
+    # The path of the current collection inside the collection tree below current_root.
+    # The following is always true:
+    #   current_path == current_root / current_collection.namespace / current_collection.name
+    current_path: Path
+
+    def prefix_current_paths(self, paths: list[str]) -> list[str]:
+        """
+        Prefix the list of given paths with ``current_path``.
+        """
+        result = []
+        for path in paths:
+            prefixed_path = (self.current_path / path).relative_to(self.current_place)
+            if prefixed_path.exists():
+                result.append(str(prefixed_path))
+        return result
+
+
+def _run_subprocess(args: list[str]) -> tuple[bytes, bytes]:
+    p = subprocess.run(args, check=True, capture_output=True)
+    return p.stdout, p.stderr
+
+
+def prepare_collections(
+    session: nox.Session,
+    *,
+    install_in_site_packages: bool,
+    extra_deps_files: list[str | os.PathLike] | None = None,
+    extra_collections: list[str] | None = None,
+    install_out_of_tree: bool = False,  # can not be used with install_in_site_packages=True
+) -> CollectionSetup | None:
     """
-    Modifies a list of paths by restricting to and/or removing paths.
+    Install collections in site-packages.
     """
-    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)]
+    if install_out_of_tree and install_in_site_packages:
+        raise ValueError(
+            "install_out_of_tree=True cannot be combined with install_in_site_packages=True"
+        )
+    if isinstance(session.virtualenv, nox.virtualenv.PassthroughEnv):
+        session.warn("No venv. Skip preparing collections...")
+        return None
+    if install_in_site_packages:
+        purelib = (
+            session.run(
+                "python",
+                "-c",
+                "import sysconfig; print(sysconfig.get_path('purelib'))",
+                silent=True,
+            )
+            or ""
+        ).strip()
+        if not purelib:
+            session.warn(
+                "Cannot find site-packages (probably due to install-only run)."
+                " Skip preparing collections..."
+            )
+            return None
+        place = Path(purelib)
+    elif install_out_of_tree:
+        place = create_temp_directory(f"antsibull-nox-{session.name}-collection-root-")
+    else:
+        place = Path(session.virtualenv.location) / "collection-root"
+    place.mkdir(exist_ok=True)
+    setup = setup_collections(
+        place,
+        _run_subprocess,
+        extra_deps_files=extra_deps_files,
+        extra_collections=extra_collections,
+        with_current=False,
+    )
+    current_setup = setup_current_tree(place, setup.current_collection)
+    return CollectionSetup(
+        collections_root=setup.root,
+        current_place=place,
+        current_root=current_setup.root,
+        current_collection=setup.current_collection,
+        current_path=t.cast(Path, current_setup.current_path),
+    )
 
 
-def add_lint(has_formatters: bool, has_codeqa: bool, has_typing: bool) -> None:
+def _run_bare_script(
+    session: nox.Session, /, name: str, *, extra_data: dict[str, t.Any] | None = None
+) -> None:
+    files = list_all_files()
+    data = prepare_data_script(
+        session,
+        base_name=name,
+        paths=files,
+        extra_data=extra_data,
+    )
+    session.run(
+        sys.executable,
+        find_data_directory() / f"{name}.py",
+        "--data",
+        data,
+        external=True,
+    )
+
+
+def add_lint(
+    *, make_lint_default: bool, has_formatters: bool, has_codeqa: bool, has_typing: bool
+) -> None:
     """
     Add nox meta session for linting.
     """
@@ -192,11 +214,14 @@ def add_lint(has_formatters: bool, has_codeqa: bool, has_typing: bool) -> None:
         dependent_sessions.append("codeqa")
     if has_typing:
         dependent_sessions.append("typing")
-    nox.session(lint, name="lint", default=True, requires=dependent_sessions)  # type: ignore
+    nox.session(  # type: ignore
+        lint, name="lint", default=make_lint_default, requires=dependent_sessions
+    )
 
 
 def add_formatters(
     *,
+    extra_code_files: list[str],
     # isort:
     run_isort: bool,
     isort_config: str | os.PathLike | None,
@@ -231,13 +256,15 @@ def add_formatters(
         if isort_config is not None:
             command.extend(["--settings-file", str(isort_config)])
         command.extend(session.posargs)
-        command.extend(filter_paths(CODE_FILES + ["noxfile.py"]))
+        command.extend(filter_paths(CODE_FILES + ["noxfile.py"] + extra_code_files))
         session.run(*command)
 
     def execute_black_for(session: nox.Session, paths: list[str]) -> None:
         if not paths:
             return
         command = ["black"]
+        if run_check:
+            command.append("--check")
         if black_config is not None:
             command.extend(["--config", str(black_config)])
         command.extend(session.posargs)
@@ -246,7 +273,9 @@ def add_formatters(
 
     def execute_black(session: nox.Session) -> None:
         if run_black and run_black_modules:
-            execute_black_for(session, filter_paths(CODE_FILES + ["noxfile.py"]))
+            execute_black_for(
+                session, filter_paths(CODE_FILES + ["noxfile.py"] + extra_code_files)
+            )
             return
         if run_black:
             paths = filter_paths(
@@ -273,8 +302,9 @@ def add_formatters(
     nox.session(formatters, name="formatters", default=False)  # type: ignore
 
 
-def add_codeqa(
+def add_codeqa(  # noqa: C901
     *,
+    extra_code_files: list[str],
     # flake8:
     run_flake8: bool,
     flake8_config: str | os.PathLike | None,
@@ -314,10 +344,31 @@ def add_codeqa(
         if flake8_config is not None:
             command.extend(["--config", str(flake8_config)])
         command.extend(session.posargs)
-        command.extend(filter_paths(CODE_FILES + ["noxfile.py"]))
+        command.extend(filter_paths(CODE_FILES + ["noxfile.py"] + extra_code_files))
+        session.run(*command)
+
+    def execute_pylint_impl(
+        session: nox.Session,
+        prepared_collections: CollectionSetup,
+        config: os.PathLike | str | None,
+        paths: list[str],
+    ) -> None:
+        command = ["pylint"]
+        if config is not None:
+            command.extend(
+                [
+                    "--rcfile",
+                    os.path.join(prepared_collections.current_collection.path, config),
+                ]
+            )
+        command.extend(["--source-roots", "."])
+        command.extend(session.posargs)
+        command.extend(prepared_collections.prefix_current_paths(paths))
         session.run(*command)
 
-    def execute_pylint(session: nox.Session) -> None:
+    def execute_pylint(
+        session: nox.Session, prepared_collections: CollectionSetup
+    ) -> None:
         if pylint_modules_rcfile is not None and pylint_modules_rcfile != pylint_rcfile:
             # Only run pylint twice when using different configurations
             module_paths = filter_paths(
@@ -330,46 +381,43 @@ def add_codeqa(
             # Otherwise run it only once using the general configuration
             module_paths = []
             other_paths = filter_paths(CODE_FILES)
-        command: list[str]
-        with ansible_collection_root() as (root, prefix):
+
+        with session.chdir(prepared_collections.current_place):
             if module_paths:
-                command = ["pylint"]
-                config = pylint_modules_rcfile or pylint_rcfile
-                if config is not None:
-                    command.extend(
-                        [
-                            "--rcfile",
-                            os.path.join(root, prefix, config),
-                        ]
-                    )
-                command.extend(["--source-roots", root])
-                command.extend(session.posargs)
-                command.extend(prefix_paths(module_paths, prefix=prefix))
-                session.run(*command)
+                execute_pylint_impl(
+                    session,
+                    prepared_collections,
+                    pylint_modules_rcfile or pylint_rcfile,
+                    module_paths,
+                )
 
             if other_paths:
-                command = ["pylint"]
-                if pylint_rcfile is not None:
-                    command.extend(
-                        ["--rcfile", os.path.join(root, prefix, pylint_rcfile)]
-                    )
-                command.extend(["--source-roots", root])
-                command.extend(session.posargs)
-                command.extend(prefix_paths(other_paths, prefix=prefix))
-                session.run(*command)
+                execute_pylint_impl(
+                    session, prepared_collections, pylint_rcfile, other_paths
+                )
 
     def codeqa(session: nox.Session) -> None:
         install(session, *compose_dependencies())
+        prepared_collections: CollectionSetup | None = None
+        if run_pylint:
+            prepared_collections = prepare_collections(
+                session,
+                install_in_site_packages=False,
+                extra_deps_files=["tests/unit/requirements.yml"],
+            )
+            if not prepared_collections:
+                session.warn("Skipping pylint...")
         if run_flake8:
             execute_flake8(session)
-        if run_pylint:
-            execute_pylint(session)
+        if run_pylint and prepared_collections:
+            execute_pylint(session, prepared_collections)
 
     nox.session(codeqa, name="codeqa", default=False)  # type: ignore
 
 
 def add_typing(
     *,
+    extra_code_files: list[str],
     run_mypy: bool,
     mypy_config: str | os.PathLike | None,
     mypy_package: str,
@@ -394,28 +442,50 @@ def add_typing(
                 deps.extend(shlex.split(extra_dep))
         return deps
 
-    def execute_mypy(session: nox.Session) -> None:
-        with ansible_collection_root() as (root, prefix):
+    def execute_mypy(
+        session: nox.Session, prepared_collections: CollectionSetup
+    ) -> None:
+        # Run mypy
+        with session.chdir(prepared_collections.current_place):
             command = ["mypy"]
             if mypy_config is not None:
                 command.extend(
-                    ["--config-file", os.path.join(root, prefix, mypy_config)]
+                    [
+                        "--config-file",
+                        os.path.join(
+                            prepared_collections.current_collection.path, mypy_config
+                        ),
+                    ]
                 )
+            command.append("--namespace-packages")
             command.append("--explicit-package-bases")
             command.extend(session.posargs)
-            command.extend(prefix_paths(CODE_FILES, prefix=prefix))
-            session.run(*command, env={"MYPYPATH": root})
+            command.extend(
+                prepared_collections.prefix_current_paths(CODE_FILES + extra_code_files)
+            )
+            session.run(
+                *command, env={"MYPYPATH": str(prepared_collections.current_place)}
+            )
 
     def typing(session: nox.Session) -> None:
         install(session, *compose_dependencies())
-        if run_mypy:
-            execute_mypy(session)
+        prepared_collections = prepare_collections(
+            session,
+            install_in_site_packages=False,
+            extra_deps_files=["tests/unit/requirements.yml"],
+        )
+        if not prepared_collections:
+            session.warn("Skipping mypy...")
+        if run_mypy and prepared_collections:
+            execute_mypy(session, prepared_collections)
 
     nox.session(typing, name="typing", default=False)  # type: ignore
 
 
 def add_lint_sessions(
     *,
+    make_lint_default: bool = True,
+    extra_code_files: list[str] | None = None,
     # isort:
     run_isort: bool = True,
     isort_config: str | os.PathLike | None = None,
@@ -451,11 +521,15 @@ def add_lint_sessions(
     has_typing = run_mypy
 
     add_lint(
-        has_formatters=has_formatters, has_codeqa=has_codeqa, has_typing=has_typing
+        has_formatters=has_formatters,
+        has_codeqa=has_codeqa,
+        has_typing=has_typing,
+        make_lint_default=make_lint_default,
     )
 
     if has_formatters:
         add_formatters(
+            extra_code_files=extra_code_files or [],
             run_isort=run_isort,
             isort_config=isort_config,
             isort_package=isort_package,
@@ -467,6 +541,7 @@ def add_lint_sessions(
 
     if has_codeqa:
         add_codeqa(
+            extra_code_files=extra_code_files or [],
             run_flake8=run_flake8,
             flake8_config=flake8_config,
             flake8_package=flake8_package,
@@ -480,6 +555,7 @@ def add_lint_sessions(
 
     if has_typing:
         add_typing(
+            extra_code_files=extra_code_files or [],
             run_mypy=run_mypy,
             mypy_config=mypy_config,
             mypy_package=mypy_package,
@@ -488,4 +564,277 @@ def add_lint_sessions(
         )
 
 
-__all__ = ["add_lint_sessions"]
+def add_docs_check(
+    *,
+    make_docs_check_default: bool = True,
+    antsibull_docs_package: str = "antsibull-docs",
+    ansible_core_package: str = "ansible-core",
+    validate_collection_refs: t.Literal["self", "dependent", "all"] | None = None,
+    extra_collections: list[str] | None = None,
+):
+    """
+    Add docs-check session for linting.
+    """
+
+    def compose_dependencies() -> list[str]:
+        deps = [antsibull_docs_package, ansible_core_package]
+        return deps
+
+    def execute_antsibull_docs(
+        session: nox.Session, prepared_collections: CollectionSetup
+    ) -> None:
+        with session.chdir(prepared_collections.current_path):
+            collections_path = f"{prepared_collections.current_place}"
+            command = [
+                "antsibull-docs",
+                "lint-collection-docs",
+                "--plugin-docs",
+                "--skip-rstcheck",
+                ".",
+            ]
+            if validate_collection_refs:
+                command.extend(["--validate-collection-refs", validate_collection_refs])
+            session.run(*command, env={"ANSIBLE_COLLECTIONS_PATH": collections_path})
+
+    def docs_check(session: nox.Session) -> None:
+        install(session, *compose_dependencies())
+        prepared_collections = prepare_collections(
+            session,
+            install_in_site_packages=False,
+            extra_collections=extra_collections,
+            install_out_of_tree=True,
+        )
+        if not prepared_collections:
+            session.warn("Skipping antsibull-docs...")
+        if prepared_collections:
+            execute_antsibull_docs(session, prepared_collections)
+
+    nox.session(  # type: ignore
+        docs_check, name="docs-check", default=make_docs_check_default
+    )
+
+
+def add_license_check(
+    *,
+    make_license_check_default: bool = True,
+    run_reuse: bool = True,
+    reuse_package: str = "reuse",
+    run_license_check: bool = True,
+    license_check_extra_ignore_paths: list[str] | None = None,
+):
+    """
+    Add license-check session for license checks.
+    """
+
+    def compose_dependencies() -> list[str]:
+        deps = []
+        if run_reuse:
+            deps.append(reuse_package)
+        return deps
+
+    def license_check(session: nox.Session) -> None:
+        install(session, *compose_dependencies())
+        if run_reuse:
+            session.run("reuse", "lint")
+        if run_license_check:
+            _run_bare_script(
+                session,
+                "license-check",
+                extra_data={
+                    "extra_ignore_paths": license_check_extra_ignore_paths or [],
+                },
+            )
+
+    nox.session(  # type: ignore
+        license_check, name="license-check", default=make_license_check_default
+    )
+
+
+@dataclass
+class ActionGroup:
+    """
+    Defines an action group.
+    """
+
+    # Name of the action group.
+    name: str
+    # Regex pattern to match modules that could belong to this action group.
+    pattern: str
+    # Doc fragment that members of the action group must have, but no other module
+    # must have
+    doc_fragment: str
+    # Exclusion list of modules that match the regex, but should not be part of the
+    # action group. All other modules matching the regex are assumed to be part of
+    # the action group.
+    exclusions: list[str] | None = None
+
+
+def add_extra_checks(
+    *,
+    make_extra_checks_default: bool = True,
+    # no-unwanted-files:
+    run_no_unwanted_files: bool = True,
+    no_unwanted_files_module_extensions: (
+        list[str] | None
+    ) = None,  # default: .cs, .ps1, .psm1, .py
+    no_unwanted_files_other_extensions: list[str] | None = None,  # default: .py, .pyi
+    no_unwanted_files_yaml_extensions: list[str] | None = None,  # default: .yml, .yaml
+    no_unwanted_files_skip_paths: list[str] | None = None,  # default: []
+    no_unwanted_files_skip_directories: list[str] | None = None,  # default: []
+    no_unwanted_files_yaml_directories: (
+        list[str] | None
+    ) = None,  # default: plugins/test/, plugins/filter/
+    no_unwanted_files_allow_symlinks: bool = False,
+    # action-groups:
+    run_action_groups: bool = False,
+    action_groups_config: list[ActionGroup] | None = None,
+):
+    """
+    Add extra-checks session for extra checks.
+    """
+
+    def execute_no_unwanted_files(session: nox.Session) -> None:
+        _run_bare_script(
+            session,
+            "no-unwanted-files",
+            extra_data={
+                "module_extensions": no_unwanted_files_module_extensions
+                or [".cs", ".ps1", ".psm1", ".py"],
+                "other_extensions": no_unwanted_files_other_extensions
+                or [".py", ".pyi"],
+                "yaml_extensions": no_unwanted_files_yaml_extensions
+                or [".yml", ".yaml"],
+                "skip_paths": no_unwanted_files_skip_paths or [],
+                "skip_directories": no_unwanted_files_skip_directories or [],
+                "yaml_directories": no_unwanted_files_yaml_directories
+                or ["plugins/test/", "plugins/filter/"],
+                "allow_symlinks": no_unwanted_files_allow_symlinks,
+            },
+        )
+
+    def execute_action_groups(session: nox.Session) -> None:
+        if action_groups_config is None:
+            session.warn("Skipping action-groups since config is not provided...")
+            return
+        _run_bare_script(
+            session,
+            "action-groups",
+            extra_data={
+                "config": [asdict(cfg) for cfg in action_groups_config],
+            },
+        )
+
+    def extra_checks(session: nox.Session) -> None:
+        if run_no_unwanted_files:
+            execute_no_unwanted_files(session)
+        if run_action_groups:
+            execute_action_groups(session)
+
+    nox.session(  # type: ignore
+        extra_checks,
+        name="extra-checks",
+        python=False,
+        default=make_extra_checks_default,
+    )
+
+
+def add_build_import_check(
+    *,
+    make_build_import_check_default: bool = True,
+    ansible_core_package: str = "ansible-core",
+    run_galaxy_importer: bool = True,
+    galaxy_importer_package: str = "galaxy-importer",
+    galaxy_importer_config_path: (
+        str | None
+    ) = None,  # https://github.com/ansible/galaxy-importer#configuration
+):
+    """
+    Add license-check session for license checks.
+    """
+
+    def compose_dependencies() -> list[str]:
+        deps = [ansible_core_package]
+        if run_galaxy_importer:
+            deps.append(galaxy_importer_package)
+        return deps
+
+    def build_import_check(session: nox.Session) -> None:
+        install(session, *compose_dependencies())
+
+        tmp = Path(session.create_tmp())
+        collection_dir = tmp / "collection"
+        remove_path(collection_dir)
+        copy_collection(Path.cwd(), collection_dir)
+
+        collection = load_collection_data_from_disk(
+            collection_dir, accept_manifest=False
+        )
+        version = collection.version
+        if not version:
+            version = "0.0.1"
+            force_collection_version(collection_dir, version=version)
+
+        with session.chdir(collection_dir):
+            build_ran = session.run("ansible-galaxy", "collection", "build") is not None
+
+        tarball = (
+            collection_dir
+            / f"{collection.namespace}-{collection.name}-{version}.tar.gz"
+        )
+        if build_ran and not tarball.is_file():
+            files = "\n".join(
+                f"* {path.name}"
+                for path in collection_dir.iterdir()
+                if not path.is_dir()
+            )
+            session.error(f"Cannot find file {tarball}! List of all files:\n{files}")
+
+        if run_galaxy_importer and tarball.is_file():
+            env = {}
+            if galaxy_importer_config_path:
+                env["GALAXY_IMPORTER_CONFIG"] = str(
+                    Path.cwd() / galaxy_importer_config_path
+                )
+            with session.chdir(collection_dir):
+                import_log = (
+                    session.run(
+                        "python",
+                        "-m",
+                        "galaxy_importer.main",
+                        tarball.name,
+                        env=env,
+                        silent=True,
+                    )
+                    or ""
+                )
+            if import_log:
+                print(import_log)
+                error_prefix = "ERROR:"
+                errors = []
+                for line in import_log.splitlines():
+                    if line.startswith(error_prefix):
+                        errors.append(line[len(error_prefix) :].strip())
+                if errors:
+                    messages = "\n".join(f"* {error}" for error in errors)
+                    session.warn(
+                        "Galaxy importer emitted the following non-fatal"
+                        f" error{'' if len(errors) == 1 else 's'}:\n{messages}"
+                    )
+
+    nox.session(  # type: ignore
+        build_import_check,
+        name="build-import-check",
+        default=make_build_import_check_default,
+    )
+
+
+__all__ = [
+    "ActionGroup",
+    "add_build_import_check",
+    "add_docs_check",
+    "add_extra_checks",
+    "add_license_check",
+    "add_lint_sessions",
+    "install",
+    "prepare_collections",
+]