antsibull-nox 0.3.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

antsibull_nox/__init__.py

@@ -17,7 +17,7 @@ from .config import (
 from .interpret_config import interpret_config
 from .sessions.ansible_test import add_ansible_test_session
 
-__version__ = "0.3.0"
+__version__ = "0.4.0"
 
 
 def load_antsibull_nox_toml() -> None:

antsibull_nox/ansible.py

@@ -253,8 +253,23 @@ def get_supported_core_versions(
     return result
 
 
+def parse_ansible_core_version(
+    version: str | AnsibleCoreVersion,
+) -> AnsibleCoreVersion:
+    """
+    Coerce a string or a AnsibleCoreVersion to a AnsibleCoreVersion.
+    """
+    if version in ("devel", "milestone"):
+        # For some reason mypy doesn't notice that
+        return t.cast(AnsibleCoreVersion, version)
+    if isinstance(version, Version):
+        return version
+    return Version.parse(version)
+
+
 __all__ = [
     "AnsibleCoreInfo",
     "get_ansible_core_info",
     "get_ansible_core_package_name",
+    "parse_ansible_core_version",
 ]

antsibull_nox/collection/data.py

@@ -10,6 +10,8 @@ Data types for collections.
 
 from __future__ import annotations
 
+import base64
+import hashlib
 from dataclasses import dataclass
 from pathlib import Path
 
@@ -98,6 +100,16 @@ class CollectionSource:
             )
         return source
 
+    def identifier(self) -> str:
+        """
+        Compute a source identifier.
+        """
+        hasher = hashlib.sha256()
+        hasher.update(self.name.encode("utf-8"))
+        hasher.update(b"::")
+        hasher.update(self.source.encode("utf-8"))
+        return base64.b32encode(hasher.digest())[:16].decode("ascii")
+
 
 __all__ = [
     "CollectionData",

antsibull_nox/collection/install.py

@@ -20,6 +20,7 @@ from pathlib import Path
 
 from antsibull_fileutils.yaml import load_yaml_file
 
+from ..ansible import AnsibleCoreVersion
 from ..paths import copy_collection as _paths_copy_collection
 from ..paths import remove_path as _remove
 from .data import CollectionData, CollectionSource, SetupResult
@@ -47,84 +48,170 @@ class _CollectionSources:
         """
         self.sources[name] = source
 
-    def get_source(self, name: str) -> CollectionSource:
+    @t.overload
+    def get_source(
+        self, name: str, *, create_default: t.Literal[True] = True
+    ) -> CollectionSource: ...
+
+    @t.overload
+    def get_source(
+        self, name: str, *, create_default: t.Literal[False]
+    ) -> CollectionSource | None: ...
+
+    def get_source(
+        self, name: str, *, create_default: bool = True
+    ) -> CollectionSource | None:
         """
         Get source for collection.
         """
         source = self.sources.get(name)
-        if source is None:
+        if source is None and create_default:
             source = CollectionSource(name, name)
         return source
 
 
+class _CollectionDownloadCache:
+    @staticmethod
+    def _parse_galaxy_filename(file: Path) -> tuple[str, str, str]:
+        """
+        Split filename into (namespace, name, version) tuple.
+        """
+        if not file.name.endswith(_TARBALL_EXTENSION):
+            raise ValueError(
+                f"Filename {file.name!r} does not end with {_TARBALL_EXTENSION}"
+            )
+        parts = file.name[: -len(_TARBALL_EXTENSION)].split("-", 2)
+        if len(parts) != 3:
+            raise ValueError(
+                f"Filename {file.name!r} does not belong to a Galaxy tarball"
+            )
+        return parts[0], parts[1], parts[2]
+
+    @staticmethod
+    def _parse_cache_filename(file: Path) -> tuple[str, str, str, str] | None:
+        """
+        Split cache filename into (namespace, name, source_id, version) tuple.
+        """
+        if not file.name.endswith(_TARBALL_EXTENSION):
+            return None
+        parts = file.name[: -len(_TARBALL_EXTENSION)].split("-", 3)
+        if len(parts) != 4:
+            return None
+        return parts[0], parts[1], parts[2], parts[3]
+
+    @staticmethod
+    def _encode_cache_filename(
+        namespace: str, name: str, version: str, source: CollectionSource
+    ) -> str:
+        return f"{namespace}-{name}-{source.identifier()}-{version}{_TARBALL_EXTENSION}"
+
+    def download_collections(
+        self, *, destination: Path, sources: list[CollectionSource], runner: Runner
+    ) -> None:
+        """
+        Given a set of collection sources, downloads these and stores them in destination.
+        """
+        destination.mkdir(exist_ok=True)
+        names = ", ".join(sorted(source.name for source in sources))
+        print(f"Downloading {names} to {destination}...")
+        sources_by_name = {}
+        for source in sources:
+            sources_by_name[source.name] = source
+            if source.name != source.source:
+                print(f"  Installing {source.name} via {source.source}...")
+        with tempfile.TemporaryDirectory(
+            prefix="antsibull-nox-galaxy-download"
+        ) as dest:
+            tempdir = Path(dest)
+            command = [
+                "ansible-galaxy",
+                "collection",
+                "download",
+                "--no-deps",
+                "--download-path",
+                str(tempdir),
+                "--",
+                *(source.source for source in sources),
+            ]
+            runner(command)
+            for file in tempdir.iterdir():
+                if file.name.endswith(_TARBALL_EXTENSION) and file.is_file():
+                    namespace, name, version = self._parse_galaxy_filename(file)
+                    source_opt = sources_by_name.get(f"{namespace}.{name}")
+                    if source_opt is None:
+                        print(
+                            f"Found unknown collection artifact {file.name!r}, ignoring..."
+                        )
+                        continue
+                    destfile = destination / self._encode_cache_filename(
+                        namespace, name, version, source_opt
+                    )
+                    _remove(destfile)
+                    shutil.move(file, destfile)
+
+    def list_downloaded_dir(
+        self, *, path: Path
+    ) -> dict[tuple[str, str], tuple[Path, str]]:
+        """
+        List contents of download cache.
+
+        Returns a dictionary mapping (collection_name, source_id) tuples to
+        (tarball_path, version) tuples.
+        """
+        if not path.is_dir():
+            return {}
+        result: dict[tuple[str, str], tuple[Path, str]] = {}
+        for file in path.iterdir():
+            if not file.is_file():
+                continue
+            parsed = self._parse_cache_filename(file)
+            if parsed is None:
+                continue
+            namespace, name, source_id, version = parsed
+            collection_name = f"{namespace}.{name}"
+            key = collection_name, source_id
+            if key in result:
+                # Determine older entry
+                old_file = result[key][0]
+                old_stat = old_file.stat()
+                new_stat = file.stat()
+                if new_stat.st_mtime > old_stat.st_mtime:
+                    older_file = old_file
+                    result[key] = file, version
+                else:
+                    older_file = file
+                # Clean up older entry
+                _remove(older_file)
+            else:
+                result[key] = file, version
+        return result
+
+
 _COLLECTION_SOURCES = _CollectionSources()
+_COLLECTION_SOURCES_PER_CORE_VERSION: dict[AnsibleCoreVersion, _CollectionSources] = {}
+_COLLECTION_DOWNLOAD_CACHE = _CollectionDownloadCache()
 _TARBALL_EXTENSION = ".tar.gz"
 _INSTALLATION_CONFIG_ENV_VAR = "ANTSIBULL_NOX_INSTALL_COLLECTIONS"
 
 
-def setup_collection_sources(collection_sources: dict[str, CollectionSource]) -> None:
+def setup_collection_sources(
+    collection_sources: dict[str, CollectionSource],
+    *,
+    ansible_core_version: AnsibleCoreVersion | None = None,
+) -> None:
     """
     Setup collection sources.
     """
+    sources = _COLLECTION_SOURCES
+    if ansible_core_version is not None:
+        sources = _COLLECTION_SOURCES_PER_CORE_VERSION.get(
+            ansible_core_version, _COLLECTION_SOURCES
+        )
+        if sources is _COLLECTION_SOURCES:
+            sources = _CollectionSources()
+            _COLLECTION_SOURCES_PER_CORE_VERSION[ansible_core_version] = sources
     for name, source in collection_sources.items():
-        _COLLECTION_SOURCES.set_source(name, source)
-
-
-def _download_collections(
-    *, destination: Path, sources: list[CollectionSource], runner: Runner
-) -> None:
-    destination.mkdir(exist_ok=True)
-    names = ", ".join(sorted(source.name for source in sources))
-    print(f"Downloading {names} to {destination}...")
-    for source in sources:
-        if source.name != source.source:
-            print(f"  Installing {source.name} via {source.source}...")
-    with tempfile.TemporaryDirectory(prefix="antsibull-nox-galaxy-download") as dest:
-        tempdir = Path(dest)
-        command = [
-            "ansible-galaxy",
-            "collection",
-            "download",
-            "--no-deps",
-            "--download-path",
-            str(tempdir),
-            "--",
-            *(source.source for source in sources),
-        ]
-        runner(command)
-        for file in tempdir.iterdir():
-            if file.name.endswith(_TARBALL_EXTENSION) and file.is_file():
-                destfile = destination / file.name
-                _remove(destfile)
-                shutil.move(file, destfile)
-
-
-def _list_downloaded_dir(*, path: Path) -> dict[str, Path]:
-    if not path.is_dir():
-        return {}
-    result: dict[str, Path] = {}
-    for file in path.iterdir():
-        if not file.name.endswith(_TARBALL_EXTENSION) or not file.is_file():
-            continue
-        basename = file.name[: -len(_TARBALL_EXTENSION)]
-        # Format: community-internal_test_tools-0.15.0, community-aws-10.0.0-dev0
-        parts = basename.split("-", 2)
-        if len(parts) != 3:
-            continue
-        full_name = ".".join(parts[:2])
-        if full_name in result:
-            old_stat = result[full_name].stat()
-            new_stat = file.stat()
-            if new_stat.st_mtime > old_stat.st_mtime:
-                older_file = result[full_name]
-                result[full_name] = file
-            else:
-                older_file = file
-            # Clean up older entry
-            _remove(older_file)
-        else:
-            result[full_name] = file
-    return result
+        sources.set_source(name, source)
 
 
 def _install_from_download_cache(
@@ -137,9 +224,21 @@ def _install_from_download_cache(
     return destination_dir
 
 
+def _get_source(
+    name: str, *, ansible_core_version: AnsibleCoreVersion
+) -> CollectionSource:
+    sources_per_version = _COLLECTION_SOURCES_PER_CORE_VERSION.get(ansible_core_version)
+    if sources_per_version:
+        result = sources_per_version.get_source(name, create_default=False)
+        if result is not None:
+            return result
+    return _COLLECTION_SOURCES.get_source(name)
+
+
 def _install_missing(
     collections: list[str],
     *,
+    ansible_core_version: AnsibleCoreVersion,
     runner: Runner,
 ) -> list[CollectionData]:
     config = os.environ.get(_INSTALLATION_CONFIG_ENV_VAR)
@@ -151,38 +250,49 @@ def _install_missing(
             f" thus cannot install missing exception{plural_s} {names}..."
         )
         return []
-    sources = [_COLLECTION_SOURCES.get_source(name) for name in collections]
+    sources = [
+        _get_source(name, ansible_core_version=ansible_core_version)
+        for name in collections
+    ]
     result: list[CollectionData] = []
-    with _update_collection_list() as updater:
+    with _update_collection_list(ansible_core_version=ansible_core_version) as updater:
         global_cache = updater.get_global_cache()
-        install: list[str] = []
+        install: list[CollectionSource] = []
         download: list[CollectionSource] = []
-        download_cache = _list_downloaded_dir(path=global_cache.download_cache)
+        download_cache = _COLLECTION_DOWNLOAD_CACHE.list_downloaded_dir(
+            path=global_cache.download_cache
+        )
         for source in sources:
             if cd := updater.find(source.name):
                 result.append(cd)
             else:
-                install.append(source.name)
-                if not download_cache.get(source.name):
+                install.append(source)
+                if not download_cache.get((source.name, source.identifier())):
                     download.append(source)
         if download:
-            _download_collections(
+            _COLLECTION_DOWNLOAD_CACHE.download_collections(
                 destination=global_cache.download_cache, sources=download, runner=runner
             )
-            download_cache = _list_downloaded_dir(path=global_cache.download_cache)
+            download_cache = _COLLECTION_DOWNLOAD_CACHE.list_downloaded_dir(
+                path=global_cache.download_cache
+            )
         if install:
-            for name in install:
-                if name not in download_cache:
+            for source in install:
+                key = source.name, source.identifier()
+                if key not in download_cache:
                     raise ValueError(
-                        f"Error: cannot find {name} in download cache"
-                        f" {global_cache.download_cache} after successful download!"
+                        f"Error: cannot find {source.name} (source ID {source.identifier()})"
+                        f" in download cache {global_cache.download_cache}"
+                        " after successful download!"
                     )
                 c_dir = _install_from_download_cache(
-                    full_name=name,
-                    tarball=download_cache[name],
-                    destination=global_cache.extracted_cache,
+                    full_name=source.name,
+                    tarball=download_cache[key][0],
+                    destination=global_cache.get_extracted_path(
+                        ansible_core_version=ansible_core_version
+                    ),
                 )
-                c_namespace, c_name = name.split(".", 1)
+                c_namespace, c_name = source.name.split(".", 1)
                 result.append(
                     updater.add_collection(
                         directory=c_dir, namespace=c_namespace, name=c_name
@@ -414,6 +524,7 @@ def setup_collections(
     destination: str | os.PathLike,
     runner: Runner,
     *,
+    ansible_core_version: AnsibleCoreVersion,
     extra_collections: list[str] | None = None,
     extra_deps_files: list[str | os.PathLike] | None = None,
     global_cache_dir: Path,
@@ -423,7 +534,9 @@ def setup_collections(
     Setup all collections in a tree structure inside the destination directory.
     """
     all_collections = get_collection_list(
-        runner=runner, global_cache_dir=global_cache_dir
+        runner=runner,
+        global_cache_dir=global_cache_dir,
+        ansible_core_version=ansible_core_version,
     )
     destination_root = Path(destination) / "ansible_collections"
     destination_root.mkdir(exist_ok=True)
@@ -451,7 +564,9 @@ def setup_collections(
         if missing.is_empty():
             break
         for collection_data in _install_missing(
-            missing.get_missing_names(), runner=runner
+            missing.get_missing_names(),
+            ansible_core_version=ansible_core_version,
+            runner=runner,
         ):
             collections_to_install[collection_data.full_name] = collection_data
             missing.remove(collection_data.full_name)

antsibull_nox/collection/search.py

@@ -21,6 +21,7 @@ from pathlib import Path
 
 from antsibull_fileutils.yaml import load_yaml_file
 
+from ..ansible import AnsibleCoreVersion
 from .data import CollectionData
 
 # Function that runs a command (and fails on non-zero return code)
@@ -49,6 +50,12 @@ class _GlobalCache:
             extracted_cache=root / "extracted",
         )
 
+    def get_extracted_path(self, *, ansible_core_version: AnsibleCoreVersion) -> Path:
+        """
+        Given an ansible-core version, returns its extracted collection cache directory.
+        """
+        return self.extracted_cache / str(ansible_core_version)
+
 
 def _load_galaxy_yml(galaxy_yml: Path) -> dict[str, t.Any]:
     try:
@@ -279,9 +286,9 @@ class CollectionList:
         )
 
     @classmethod
-    def collect(cls, *, runner: Runner, global_cache: _GlobalCache) -> CollectionList:
+    def collect_global(cls, *, runner: Runner) -> CollectionList:
         """
-        Search for a list of collections. The result is not cached.
+        Search for a global list of collections. The result is not cached.
         """
         found_collections = {}
         for collection_data in _fs_list_local_collections():
@@ -291,7 +298,25 @@ class CollectionList:
                 # Similar to Ansible, we use the first match
                 if collection_data.full_name not in found_collections:
                     found_collections[collection_data.full_name] = collection_data
-        for collection_data in _fs_list_global_cache(global_cache.extracted_cache):
+        return cls.create(found_collections)
+
+    @classmethod
+    def collect_local(
+        cls,
+        *,
+        ansible_core_version: AnsibleCoreVersion,
+        global_cache: _GlobalCache,
+        current: CollectionData,
+    ) -> CollectionList:
+        """
+        Search for a list of collections from a local cache path. The result is not cached.
+        """
+        found_collections = {
+            current.full_name: current,
+        }
+        for collection_data in _fs_list_global_cache(
+            global_cache.get_extracted_path(ansible_core_version=ansible_core_version)
+        ):
             # Similar to Ansible, we use the first match
             if collection_data.full_name not in found_collections:
                 found_collections[collection_data.full_name] = collection_data
@@ -313,6 +338,18 @@ class CollectionList:
             current=self.current,
         )
 
+    def merge_with(self, other: CollectionList) -> CollectionList:
+        """
+        Merge this collection list with another (local) one.
+        """
+        result = dict(self.collection_map)
+        for collection in other.collections:
+            # Similar to Ansible, we use the first match.
+            # For merge, this means we prefer self over other.
+            if collection.full_name not in result:
+                result[collection.full_name] = collection
+        return CollectionList.create(result)
+
     def _add(self, collection: CollectionData, *, force: bool = True) -> bool:
         if not force and collection.full_name in self.collection_map:
             return False
@@ -323,16 +360,23 @@ class CollectionList:
 
 class _CollectionListUpdater:
     def __init__(
-        self, *, owner: "_CollectionListSingleton", collection_list: CollectionList
+        self,
+        *,
+        owner: "_CollectionListSingleton",
+        merged_collection_list: CollectionList,
+        local_collection_list: CollectionList,
+        ansible_core_version: AnsibleCoreVersion,
     ) -> None:
         self._owner = owner
-        self._collection_list = collection_list
+        self._merged_collection_list = merged_collection_list
+        self._local_collection_list = local_collection_list
+        self._ansible_core_version = ansible_core_version
 
     def find(self, name: str) -> CollectionData | None:
         """
         Find a collection for a given name.
         """
-        return self._collection_list.find(name)
+        return self._merged_collection_list.find(name)
 
     def add_collection(
         self, *, directory: Path, namespace: str, name: str
@@ -341,9 +385,15 @@ class _CollectionListUpdater:
         Add a new collection to the cache.
         """
         # pylint: disable-next=protected-access
-        return self._owner._add_collection(
-            directory=directory, namespace=namespace, name=name
+        result = self._owner._add_collection(
+            directory=directory,
+            namespace=namespace,
+            name=name,
+            ansible_core_version=self._ansible_core_version,
         )
+        self._merged_collection_list._add(result)  # pylint: disable=protected-access
+        self._local_collection_list._add(result)  # pylint: disable=protected-access
+        return result
 
     def get_global_cache(self) -> _GlobalCache:
         """
@@ -356,7 +406,10 @@ class _CollectionListSingleton:
     _lock = threading.Lock()
 
     _global_cache_dir: Path | None = None
-    _collection_list: CollectionList | None = None
+    _global_collection_list: CollectionList | None = None
+    _global_collection_list_per_ansible_core_version: dict[
+        AnsibleCoreVersion, CollectionList
+    ] = {}
 
     def setup(self, *, global_cache_dir: Path) -> None:
         """
@@ -378,30 +431,48 @@ class _CollectionListSingleton:
         Clear collection cache.
         """
         with self._lock:
-            self._collection_list = None
+            self._global_collection_list = None
+            self._global_collection_list_per_ansible_core_version.clear()
 
-    def get_cached(self) -> CollectionList | None:
+    def get_cached(
+        self, *, ansible_core_version: AnsibleCoreVersion | None = None
+    ) -> CollectionList | None:
         """
         Return cached list of collections, if present.
         Do not modify the result!
         """
-        return self._collection_list
+        if ansible_core_version is None:
+            return self._global_collection_list
+        return self._global_collection_list_per_ansible_core_version.get(
+            ansible_core_version
+        )
 
-    def get(self, *, runner: Runner) -> CollectionList:
+    def get(
+        self, *, ansible_core_version: AnsibleCoreVersion, runner: Runner
+    ) -> CollectionList:
         """
         Search for a list of collections. The result is cached.
         """
         with self._lock:
             if self._global_cache_dir is None:
                 raise ValueError("Internal error: global cache dir not setup")
-            result = self._collection_list
-            if result is None:
-                result = CollectionList.collect(
-                    runner=runner,
+            global_list = self._global_collection_list
+            if global_list is None:
+                global_list = CollectionList.collect_global(runner=runner)
+                self._global_collection_list = global_list
+            local_list = self._global_collection_list_per_ansible_core_version.get(
+                ansible_core_version
+            )
+            if local_list is None:
+                local_list = CollectionList.collect_local(
                     global_cache=_GlobalCache.create(root=self._global_cache_dir),
+                    ansible_core_version=ansible_core_version,
+                    current=global_list.current,
                 )
-                self._collection_list = result
-        return result.clone()
+                self._global_collection_list_per_ansible_core_version[
+                    ansible_core_version
+                ] = local_list
+        return global_list.merge_with(local_list)
 
     def _get_global_cache(self) -> _GlobalCache:
         """
@@ -412,26 +483,45 @@ class _CollectionListSingleton:
         return _GlobalCache.create(root=self._global_cache_dir)
 
     def _add_collection(
-        self, *, directory: Path, namespace: str, name: str
+        self,
+        *,
+        directory: Path,
+        namespace: str,
+        name: str,
+        ansible_core_version: AnsibleCoreVersion,
     ) -> CollectionData:
         """
         Add collection in directory if the collection list has been cached.
         """
-        if not self._collection_list:
-            raise ValueError("Internal error: collections not listed")
+        local_list = self._global_collection_list_per_ansible_core_version.get(
+            ansible_core_version
+        )
+        if not local_list:
+            raise ValueError(
+                f"Internal error: collections not listed for {ansible_core_version}"
+            )
         data = load_collection_data_from_disk(directory, namespace=namespace, name=name)
-        self._collection_list._add(data)  # pylint: disable=protected-access
+        local_list._add(data)  # pylint: disable=protected-access
         return data
 
     @contextmanager
-    def _update_collection_list(self) -> t.Iterator[_CollectionListUpdater]:
+    def _update_collection_list(
+        self, *, ansible_core_version: AnsibleCoreVersion
+    ) -> t.Iterator[_CollectionListUpdater]:
         with self._lock:
-            if not self._collection_list or self._global_cache_dir is None:
+            global_list = self._global_collection_list
+            local_list = self._global_collection_list_per_ansible_core_version.get(
+                ansible_core_version
+            )
+            if not global_list or self._global_cache_dir is None or local_list is None:
                 raise ValueError(
                     "Internal error: collections not listed or global cache not setup"
                 )
             yield _CollectionListUpdater(
-                owner=self, collection_list=self._collection_list
+                owner=self,
+                merged_collection_list=global_list.merge_with(local_list),
+                local_collection_list=local_list,
+                ansible_core_version=ansible_core_version,
             )
 
 
@@ -439,18 +529,26 @@ _COLLECTION_LIST = _CollectionListSingleton()
 
 
 @contextmanager
-def _update_collection_list() -> t.Iterator[_CollectionListUpdater]:
+def _update_collection_list(
+    *, ansible_core_version: AnsibleCoreVersion
+) -> t.Iterator[_CollectionListUpdater]:
     # pylint: disable-next=protected-access
-    with _COLLECTION_LIST._update_collection_list() as result:
+    with _COLLECTION_LIST._update_collection_list(
+        ansible_core_version=ansible_core_version
+    ) as result:
         yield result
 
 
-def get_collection_list(*, runner: Runner, global_cache_dir: Path) -> CollectionList:
+def get_collection_list(
+    *, runner: Runner, global_cache_dir: Path, ansible_core_version: AnsibleCoreVersion
+) -> CollectionList:
     """
     Search for a list of collections. The result is cached.
     """
     _COLLECTION_LIST.setup(global_cache_dir=global_cache_dir)
-    return _COLLECTION_LIST.get(runner=runner)
+    return _COLLECTION_LIST.get(
+        runner=runner, ansible_core_version=ansible_core_version
+    )
 
 
 __all__ = [

antsibull_nox/config.py

@@ -340,6 +340,9 @@ class Config(_BaseModel):
     """
 
     collection_sources: dict[CollectionName, CollectionSource] = {}
+    collection_sources_per_ansible: dict[
+        PAnsibleCoreVersion, dict[CollectionName, CollectionSource]
+    ] = {}
     sessions: Sessions = Sessions()
 
 

antsibull_nox/data/file-yamllint.py

@@ -0,0 +1,138 @@
+#!/usr/bin/env python
+
+# Copyright (c) 2025, 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
+
+"""Make sure all plugin and module documentation adheres to yamllint."""
+
+from __future__ import annotations
+
+import io
+import os
+import sys
+import traceback
+import typing as t
+
+from antsibull_nox_data_util import setup  # type: ignore
+from yamllint import linter
+from yamllint.cli import find_project_config_filepath
+from yamllint.config import YamlLintConfig
+from yamllint.linter import PROBLEM_LEVELS
+
+REPORT_LEVELS: set[PROBLEM_LEVELS] = {
+    "warning",
+    "error",
+}
+
+
+def lint(
+    *,
+    errors: list[dict[str, t.Any]],
+    path: str,
+    data: str,
+    config: YamlLintConfig,
+) -> None:
+    try:
+        problems = linter.run(
+            io.StringIO(data),
+            config,
+            path,
+        )
+        for problem in problems:
+            if problem.level not in REPORT_LEVELS:
+                continue
+            msg = f"{problem.level}: {problem.desc}"
+            if problem.rule:
+                msg += f"  ({problem.rule})"
+            errors.append(
+                {
+                    "path": path,
+                    "line": problem.line,
+                    "col": problem.column,
+                    "message": msg,
+                }
+            )
+    except Exception as exc:
+        error = str(exc).replace("\n", " / ")
+        errors.append(
+            {
+                "path": path,
+                "line": 1,
+                "col": 1,
+                "message": (
+                    f"Internal error while linting YAML: exception {type(exc)}:"
+                    f" {error}; traceback: {traceback.format_exc()!r}"
+                ),
+            }
+        )
+
+
+def process_yaml_file(
+    errors: list[dict[str, t.Any]],
+    path: str,
+    config: YamlLintConfig,
+) -> None:
+    try:
+        with open(path, "rt", encoding="utf-8") as stream:
+            data = stream.read()
+    except Exception as exc:
+        errors.append(
+            {
+                "path": path,
+                "line": 1,
+                "col": 1,
+                "message": (
+                    f"Error while parsing Python code: exception {type(exc)}:"
+                    f" {exc}; traceback: {traceback.format_exc()!r}"
+                ),
+            }
+        )
+        return
+
+    lint(
+        errors=errors,
+        path=path,
+        data=data,
+        config=config,
+    )
+
+
+def main() -> int:
+    """Main entry point."""
+    paths, extra_data = setup()
+    config: str | None = extra_data.get("config")
+
+    if config is None:
+        config = find_project_config_filepath()
+
+    if config:
+        yamllint_config = YamlLintConfig(file=config)
+    else:
+        yamllint_config = YamlLintConfig(content="extends: default")
+
+    errors: list[dict[str, t.Any]] = []
+    for path in paths:
+        if not os.path.isfile(path):
+            continue
+        process_yaml_file(errors, path, yamllint_config)
+
+    errors.sort(
+        key=lambda error: (error["path"], error["line"], error["col"], error["message"])
+    )
+    for error in errors:
+        prefix = f"{error['path']}:{error['line']}:{error['col']}: "
+        msg = error["message"]
+        if "note" in error:
+            msg = f"{msg}\nNote: {error['note']}"
+        for i, line in enumerate(msg.splitlines()):
+            print(f"{prefix}{line}")
+            if i == 0:
+                prefix = " " * len(prefix)
+
+    return len(errors) > 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

antsibull_nox/data/plugin-yamllint.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python
 
-# Copyright (c) 2024, Felix Fontein <felix@fontein.de>
+# Copyright (c) 2025, 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
@@ -44,6 +44,13 @@ def lint(
     config: YamlLintConfig,
     extra_for_errors: dict[str, t.Any] | None = None,
 ) -> None:
+    # If the string start with optional whitespace + linebreak, skip that line
+    idx = data.find("\n")
+    if idx >= 0 and (idx == 0 or data[:idx].isspace()):
+        data = data[idx + 1 :]
+        row_offset += 1
+        col_offset = 0
+
     try:
         problems = linter.run(
             io.StringIO(data),
@@ -84,6 +91,20 @@ def lint(
             errors[-1].update(extra_for_errors)
 
 
+def iterate_targets(
+    assignment: ast.Assign,
+) -> t.Iterable[tuple[ast.Constant, str, str]]:
+    if not isinstance(assignment.value, ast.Constant):
+        return
+    if not isinstance(assignment.value.value, str):
+        return
+    for target in assignment.targets:
+        try:
+            yield assignment.value, assignment.value.value, target.id  # type: ignore
+        except AttributeError:
+            continue
+
+
 def process_python_file(
     errors: list[dict[str, t.Any]],
     path: str,
@@ -107,33 +128,39 @@ def process_python_file(
         )
         return
 
-    # We look for top-level assignments
+    is_doc_fragment = path.startswith("plugins/doc_fragments/")
+
+    # We look for top-level assignments and classes
     for child in root.body:
+        if (
+            is_doc_fragment
+            and isinstance(child, ast.ClassDef)
+            and child.name == "ModuleDocFragment"
+        ):
+            for fragment in child.body:
+                if not isinstance(fragment, ast.Assign):
+                    continue
+                for constant, data, fragment_name in iterate_targets(fragment):
+                    lint(
+                        errors=errors,
+                        path=path,
+                        data=data,
+                        row_offset=constant.lineno - 1,
+                        col_offset=constant.col_offset - 1,
+                        section=fragment_name,
+                        config=config,
+                    )
         if not isinstance(child, ast.Assign):
             continue
-        if not isinstance(child.value, ast.Constant):
-            continue
-        if not isinstance(child.value.value, str):
-            continue
-        for target in child.targets:
-            try:
-                section = target.id  # type: ignore
-            except AttributeError:
-                continue
+        for constant, data, section in iterate_targets(child):
             if section not in ("DOCUMENTATION", "EXAMPLES", "RETURN"):
                 continue
 
-            # Extract value and offsets
-            data = child.value.value
-            row_offset = child.value.lineno - 1
-            col_offset = child.value.col_offset - 1
-
-            # If the string start with optional whitespace + linebreak, skip that line
-            idx = data.find("\n")
-            if idx >= 0 and (idx == 0 or data[:idx].isspace()):
-                data = data[idx + 1 :]
-                row_offset += 1
-                col_offset = 0
+            # Handle special values
+            if data in ("#", " # ") and section == "RETURN":
+                # Not skipping it here could result in all kind of linting errors,
+                # like no document start, or trailing space.
+                continue
 
             # Check for non-YAML examples
             if section == EXAMPLES_SECTION:
@@ -146,8 +173,8 @@ def process_python_file(
                 errors=errors,
                 path=path,
                 data=data,
-                row_offset=row_offset,
-                col_offset=col_offset,
+                row_offset=constant.lineno - 1,
+                col_offset=constant.col_offset - 1,
                 section=section,
                 config=config_examples if section == EXAMPLES_SECTION else config,
             )

antsibull_nox/interpret_config.py

@@ -46,6 +46,18 @@ def _interpret_config(config: Config) -> None:
                 for name, source in config.collection_sources.items()
             }
         )
+    if config.collection_sources_per_ansible:
+        for (
+            ansible_core_version,
+            collection_sources,
+        ) in config.collection_sources_per_ansible.items():
+            setup_collection_sources(
+                {
+                    name: CollectionSource(name=name, source=source.source)
+                    for name, source in collection_sources.items()
+                },
+                ansible_core_version=ansible_core_version,
+            )
 
 
 def _convert_action_groups(

antsibull_nox/sessions/ansible_lint.py

@@ -44,6 +44,8 @@ def add_ansible_lint(
         command = ["ansible-lint", "--offline"]
         if strict:
             command.append("--strict")
+        if session.posargs:
+            command.extend(session.posargs)
         session.run(*command, env=env)
 
     ansible_lint.__doc__ = "Run ansible-lint."

antsibull_nox/sessions/ansible_test.py

@@ -22,6 +22,7 @@ from ..ansible import (
     get_ansible_core_info,
     get_ansible_core_package_name,
     get_supported_core_versions,
+    parse_ansible_core_version,
 )
 from ..paths import copy_directory_tree_into
 from ..python import get_installed_python_versions
@@ -33,17 +34,6 @@ from .utils import (
 )
 
 
-def _parse_ansible_core_version(
-    version: str | AnsibleCoreVersion,
-) -> AnsibleCoreVersion:
-    if version in ("devel", "milestone"):
-        # For some reason mypy doesn't notice that
-        return t.cast(AnsibleCoreVersion, version)
-    if isinstance(version, Version):
-        return version
-    return Version.parse(version)
-
-
 def add_ansible_test_session(
     *,
     name: str,
@@ -67,7 +57,7 @@ def add_ansible_test_session(
 
     Returns a list of Python versions set for this session.
     """
-    parsed_ansible_core_version = _parse_ansible_core_version(ansible_core_version)
+    parsed_ansible_core_version = parse_ansible_core_version(ansible_core_version)
 
     def compose_dependencies() -> list[str]:
         deps = [
@@ -84,6 +74,7 @@ def add_ansible_test_session(
         install(session, *compose_dependencies())
         prepared_collections = prepare_collections(
             session,
+            ansible_core_version=parsed_ansible_core_version,
             install_in_site_packages=False,
             extra_deps_files=extra_deps_files,
             install_out_of_tree=True,
@@ -210,7 +201,7 @@ def _parse_min_max_except(
         max_version = Version.parse(max_version)
     if except_versions is None:
         return min_version, max_version, None
-    evs = tuple(_parse_ansible_core_version(version) for version in except_versions)
+    evs = tuple(parse_ansible_core_version(version) for version in except_versions)
     return min_version, max_version, evs
 
 

antsibull_nox/sessions/collections.py

@@ -18,6 +18,7 @@ from pathlib import Path
 
 import nox
 
+from ..ansible import AnsibleCoreVersion, parse_ansible_core_version
 from ..collection import (
     CollectionData,
     setup_collections,
@@ -76,6 +77,7 @@ def _run_subprocess(args: list[str]) -> tuple[bytes, bytes]:
 def prepare_collections(
     session: nox.Session,
     *,
+    ansible_core_version: AnsibleCoreVersion | str | None = None,
     install_in_site_packages: bool,
     extra_deps_files: list[str | os.PathLike] | None = None,
     extra_collections: list[str] | None = None,
@@ -84,6 +86,11 @@ def prepare_collections(
     """
     Install collections in site-packages.
     """
+    parsed_ansible_core_version = (
+        parse_ansible_core_version(ansible_core_version)
+        if ansible_core_version is not None
+        else "devel"
+    )
     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"
@@ -116,6 +123,7 @@ def prepare_collections(
     setup = setup_collections(
         place,
         _run_subprocess,
+        ansible_core_version=parsed_ansible_core_version,
         extra_deps_files=extra_deps_files,
         extra_collections=extra_collections,
         with_current=False,

antsibull_nox/sessions/lint.py

@@ -10,6 +10,7 @@ Create nox lint sessions.
 
 from __future__ import annotations
 
+import json
 import os
 import shlex
 from pathlib import Path
@@ -29,6 +30,7 @@ from .utils import (
     compose_description,
     install,
     run_bare_script,
+    silence_run_verbosity,
 )
 
 CODE_FILES = [
@@ -189,6 +191,28 @@ def add_formatters(
     nox.session(name="formatters", default=False)(formatters)
 
 
+def process_pylint_errors(
+    session: nox.Session,
+    prepared_collections: CollectionSetup,
+    output: str,
+) -> None:
+    """
+    Process errors reported by pylint in 'json2' format.
+    """
+    data = json.loads(output)
+    found_error = False
+    if data["messages"]:
+        for message in data["messages"]:
+            path = os.path.relpath(
+                message["absolutePath"], prepared_collections.current_path
+            )
+            prefix = f"{path}:{message['line']}:{message['column']}: [{message['messageId']}]"
+            print(f"{prefix} {message['message']} [{message['symbol']}]")
+            found_error = True
+    if found_error:
+        session.error("Pylint failed")
+
+
 def add_codeqa(  # noqa: C901
     *,
     extra_code_files: list[str],
@@ -249,9 +273,17 @@ def add_codeqa(  # noqa: C901
                 ]
             )
         command.extend(["--source-roots", "."])
+        command.extend(["--output-format", "json2"])
         command.extend(session.posargs)
         command.extend(prepared_collections.prefix_current_paths(paths))
-        session.run(*command)
+        with silence_run_verbosity():
+            # Exit code is OR of some of 1, 2, 4, 8, 16
+            output = session.run(
+                *command, silent=True, success_codes=list(range(0, 32))
+            )
+
+        if output:
+            process_pylint_errors(session, prepared_collections, output)
 
     def execute_pylint(
         session: nox.Session, prepared_collections: CollectionSetup
@@ -335,29 +367,22 @@ def add_yamllint(
     def execute_yamllint(session: nox.Session) -> None:
         # Run yamllint
         all_files = list_all_files()
-        cwd = Path.cwd()
         all_yaml_filenames = [
-            str(file.relative_to(cwd))
-            for file in all_files
-            if file.name.lower().endswith((".yml", ".yaml"))
+            file for file in all_files if file.name.lower().endswith((".yml", ".yaml"))
         ]
         if not all_yaml_filenames:
             session.warn("Skipping yamllint since no YAML file was found...")
             return
 
-        command = ["yamllint"]
-        if yamllint_config is not None:
-            command.extend(
-                [
-                    "-c",
-                    str(yamllint_config),
-                ]
-            )
-        command.append("--strict")
-        command.append("--")
-        command.extend(all_yaml_filenames)
-        command.extend(session.posargs)
-        session.run(*command)
+        run_bare_script(
+            session,
+            "file-yamllint",
+            use_session_python=True,
+            files=all_yaml_filenames,
+            extra_data={
+                "config": to_str(yamllint_config),
+            },
+        )
 
     def execute_plugin_yamllint(session: nox.Session) -> None:
         # Run yamllint
@@ -415,6 +440,40 @@ def add_yamllint(
     nox.session(name="yamllint", default=False)(yamllint)
 
 
+def process_mypy_errors(
+    session: nox.Session,
+    prepared_collections: CollectionSetup,
+    output: str,
+) -> None:
+    """
+    Process errors reported by mypy in 'json' format.
+    """
+    found_error = False
+    for line in output.splitlines():
+        if not line.strip():
+            continue
+        try:
+            data = json.loads(line)
+            path = os.path.relpath(
+                prepared_collections.current_place / data["file"],
+                prepared_collections.current_path,
+            )
+            prefix = f"{path}:{data['line']}:{data['column']}: [{data['severity']}]"
+            if data["code"]:
+                print(f"{prefix} {data['message']} [{data['code']}]")
+            else:
+                print(f"{prefix} {data['message']}")
+            if data["hint"]:
+                prefix = " " * len(prefix)
+                for hint in data["hint"].splitlines():
+                    print(f"{prefix} {hint}")
+        except Exception:  # pylint: disable=broad-exception-caught
+            session.warn(f"Cannot parse mypy output: {line}")
+        found_error = True
+    if found_error:
+        session.error("Type checking failed")
+
+
 def add_typing(
     *,
     extra_code_files: list[str],
@@ -459,13 +518,21 @@ def add_typing(
                 )
             command.append("--namespace-packages")
             command.append("--explicit-package-bases")
+            command.extend(["--output", "json"])
             command.extend(session.posargs)
             command.extend(
                 prepared_collections.prefix_current_paths(CODE_FILES + extra_code_files)
             )
-            session.run(
-                *command, env={"MYPYPATH": str(prepared_collections.current_place)}
-            )
+            with silence_run_verbosity():
+                output = session.run(
+                    *command,
+                    env={"MYPYPATH": str(prepared_collections.current_place)},
+                    silent=True,
+                    success_codes=(0, 1, 2),
+                )
+
+            if output:
+                process_mypy_errors(session, prepared_collections, output)
 
     def typing(session: nox.Session) -> None:
         install(session, *compose_dependencies())

{antsibull_nox-0.3.0.dist-info → antsibull_nox-0.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: antsibull-nox
-Version: 0.3.0
+Version: 0.4.0
 Summary: Changelog tool for Ansible-core and Ansible collections
 Project-URL: Documentation, https://ansible.readthedocs.io/projects/antsibull-nox/
 Project-URL: Source code, https://github.com/ansible-community/antsibull-nox/

{antsibull_nox-0.3.0.dist-info → antsibull_nox-0.4.0.dist-info}/RECORD

@@ -1,40 +1,41 @@
-antsibull_nox/__init__.py,sha256=oivrdT1a_loZAmf254Apt3h5_-Gp1ZnJkOXa40tTEc8,845
+antsibull_nox/__init__.py,sha256=D9rbPsKuklFL2MNeCAGCo6Qrm1C71Gaje9Om-vviX4k,845
 antsibull_nox/_pydantic.py,sha256=VTIh-u0TpWvnY6Dhe4ba8nAmR2tYmz4PXNp2_8Sr9pw,3203
-antsibull_nox/ansible.py,sha256=_PugP3a6JXijptFwuUki5nq_66VA8e9gVZUpA5HewVg,8891
+antsibull_nox/ansible.py,sha256=2EgaPK9ckS_KYTgpvb5HU9UOb6q5dpP3Az8sr1S7MU4,9346
 antsibull_nox/cli.py,sha256=NKeRlWc_0taNRcZcdMv9LHZ5nCz8-DEJxBLPxJ9vFYQ,3358
-antsibull_nox/config.py,sha256=bgvjfB005xS2vXXsGSZPIAs9vxKIg30bleYqm5EwdJM,10916
+antsibull_nox/config.py,sha256=SNiqRhu5P6XS-Uve0faLTEG0THaMEoiYti-n9-f_Kec,11037
 antsibull_nox/data_util.py,sha256=7FVoqESEc-_QdqrQ16K1AHRVHEglNbRCH_mNaYDJ7a4,953
 antsibull_nox/init.py,sha256=eRltIrS3AcHqEHk2yNAqJXv7kR6m_ysvFxIHpowd-2M,2259
-antsibull_nox/interpret_config.py,sha256=OjlHtLn22JAZBLycOndIjZVqzx2-bcbJahygJmBg6NQ,10367
+antsibull_nox/interpret_config.py,sha256=tEG6Hr7kQVpZrSAbprSqrlsVa7oPfUUcKd7WxiC5t84,10844
 antsibull_nox/lint_config.py,sha256=ZnsUbX6IdQK_IP9nvs8Kk6jb5lPdiREFSHAUuEGGceU,3848
 antsibull_nox/paths.py,sha256=86HOynhCMTVop3ml_77JI06vM9nyK7PHMzLP_4M0V88,6317
 antsibull_nox/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 antsibull_nox/python.py,sha256=0pyGqgwsuyc0BhzoXNZLTLbjaFA4kAYEHrFD6A1o1-o,2113
 antsibull_nox/utils.py,sha256=lgBNuJ67Agl9YpFNWCjr6TBUcbC1LroZrJkv6S5VuxA,2437
 antsibull_nox/collection/__init__.py,sha256=2k6uYdiPjAgJgmz5oviYpu2Sh5ZSKSJEJCR01iz-29A,1494
-antsibull_nox/collection/data.py,sha256=sacVZF517x54B3G6F0hW8fTpEF7zyB8exSQJO9mvhLk,2609
+antsibull_nox/collection/data.py,sha256=HmnASNuv97xFM08gYuQcAF3Nz6Oc6eXd5NN-wbMtYUU,2966
 antsibull_nox/collection/extract.py,sha256=qNVknQRtRrCt10aawuU1Z6NTs16CA1bUEX3WDGBw68g,684
-antsibull_nox/collection/install.py,sha256=DbnXUBzQlzW6TzU_TAszuApix2F2n7w1AcUcPZ4Q4G4,17082
-antsibull_nox/collection/search.py,sha256=peE8JQfHSkHS82NgZfARSF-k_mril_tpwj4QSkdJpOo,15539
+antsibull_nox/collection/install.py,sha256=xRXJ0kY8J1eOMmtHBZC6DqG38BF-RhjhvLF-GRT-Bb0,21622
+antsibull_nox/collection/search.py,sha256=WZkcgNldl-feAqtKvn9fMMFxJ46kLeS0mqU-5R6yt7o,19296
 antsibull_nox/data/action-groups.py,sha256=qLuh2YqIpc6i2jpWFzjtFhZhx6_SDbbvJe6VH7EXrqg,6934
 antsibull_nox/data/antsibull-nox-lint-config.py,sha256=tXkKd9AqgfDs5w7S6OaBIt9HnT0KSbiQIU9tFxtYE2U,657
 antsibull_nox/data/antsibull_nox_data_util.py,sha256=D4i_sKxjAeZuDV-z9Ibow0YYIqhXo2V_YC0LONLcEXM,2931
+antsibull_nox/data/file-yamllint.py,sha256=hlS9tULwQSUMkdbYFfGtQGcPSj2scxEay6IalQfjSFE,3625
 antsibull_nox/data/license-check.py,sha256=or3GyQC0WWYMxMqL-369krGsHaySH1vX-2fwpRyJGp0,5665
 antsibull_nox/data/license-check.py.license,sha256=iPdFtdkeE3E2nCB-M5KHevbz4d5I-6ymOnKNTc954Dw,218
 antsibull_nox/data/no-unwanted-files.py,sha256=_B3m-XWvWpdzGN-XAP8rLIS_5RMJGntFWL-Jy0WY9Mc,2959
-antsibull_nox/data/plugin-yamllint.py,sha256=zobRajdVAemXbuAzyIjr485T-EzhbzW1JH--UwUswf0,7436
+antsibull_nox/data/plugin-yamllint.py,sha256=bPIFmNwuTznaUjUhebccFa0IF_joyjIO7d3uF2HqjZQ,8466
 antsibull_nox/sessions/__init__.py,sha256=4wTTO1E6rdCz4pVMuGUeuXi_vqFaH4whAL9qcjfOqto,2022
-antsibull_nox/sessions/ansible_lint.py,sha256=TzKqxbUHO2nmvJtKqh1hM9HDoCxDr8iNbbSzp8SNkN4,1589
-antsibull_nox/sessions/ansible_test.py,sha256=hR6T-RH2epWAUUsmX3SIzDhdRa5jsVkaH_r_mbaoIAo,20624
+antsibull_nox/sessions/ansible_lint.py,sha256=ik2heGsvpRwYm_4XGwlm53UvWQ_7FHDWaBt7ttvUYbU,1661
+antsibull_nox/sessions/ansible_test.py,sha256=uZ5fa9fBY-D4BBWqgl1bI-GfpKmXAu9YKC5G4ajum18,20379
 antsibull_nox/sessions/build_import_check.py,sha256=kdr_Cqc0jb8XQQ-2QL-g_X7wgezE04oMVFCPr7a34iA,4719
-antsibull_nox/sessions/collections.py,sha256=t_j1UNgJDvehj7PRQ-67DrmZmauh2uECL8kaRCnKoEY,4324
+antsibull_nox/sessions/collections.py,sha256=nhj_W2tbnsVJw6p7NkyP1xvmr3ZUmSJzwVuK0HE3oxw,4681
 antsibull_nox/sessions/docs_check.py,sha256=mVYt278xy5AVwo5rCf6FLZlhqBiEYgJ3mmWsVBShKD0,2344
 antsibull_nox/sessions/extra_checks.py,sha256=sBn0YFD8cM3OqeQ4UgYwD0NAcjKnYoy2zd8q-z4Xl2I,4110
 antsibull_nox/sessions/license_check.py,sha256=t5ut4ZluhFfk-qE6kcU8VNdvIGvzND81N7WCsbA4jLc,1824
-antsibull_nox/sessions/lint.py,sha256=2a2F-Q3VqCUCxEM4r9YFHZTGwe39VxbPJBQO6HX6hQ0,19298
+antsibull_nox/sessions/lint.py,sha256=Idl3g3CB_zqlDbrCvItkjvYMw4TzbBcQWQnYLt5AL5Y,21639
 antsibull_nox/sessions/utils.py,sha256=rrQdzmjdrLQula8t-BCTKbO-tAmzfOKHNn1pN2B1QVc,5632
-antsibull_nox-0.3.0.dist-info/METADATA,sha256=wFsgoXsDAjCLOcSSoPZod69otcwmEnMpsKz5LUn7YUc,7670
-antsibull_nox-0.3.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-antsibull_nox-0.3.0.dist-info/entry_points.txt,sha256=solWA9TCB37UlaGk8sHXxJg-k1HWckfKdncHDBsVSsI,57
-antsibull_nox-0.3.0.dist-info/licenses/LICENSES/GPL-3.0-or-later.txt,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-antsibull_nox-0.3.0.dist-info/RECORD,,
+antsibull_nox-0.4.0.dist-info/METADATA,sha256=h--FXM-iETEiwgpBeIGAQajtcGMWAkwjKmyuFoOCZFg,7670
+antsibull_nox-0.4.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+antsibull_nox-0.4.0.dist-info/entry_points.txt,sha256=solWA9TCB37UlaGk8sHXxJg-k1HWckfKdncHDBsVSsI,57
+antsibull_nox-0.4.0.dist-info/licenses/LICENSES/GPL-3.0-or-later.txt,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+antsibull_nox-0.4.0.dist-info/RECORD,,