antsibull-fileutils 1.0.0__py3-none-any.whl

antsibull_fileutils/__init__.py

@@ -0,0 +1,14 @@
+# 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: 2020, Ansible Project
+
+"""
+Shared code used by tools for building the Ansible distribution
+"""
+
+from __future__ import annotations
+
+__version__ = "1.0.0"
+
+__all__ = ("__version__",)

antsibull_fileutils/copier.py

@@ -0,0 +1,150 @@
+# 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: 2024, Ansible Project
+
+"""
+Directory and collection copying helpers.
+"""
+
+from __future__ import annotations
+
+import os
+import shutil
+import tempfile
+import typing as t
+
+from antsibull_fileutils.vcs import list_git_files
+
+if t.TYPE_CHECKING:
+    from _typeshed import StrPath
+
+
+class CopierError(Exception):
+    pass
+
+
+class Copier:
+    """
+    Allows to copy directories.
+    """
+
+    def __init__(self, *, log_debug: t.Callable[[str], None] | None = None):
+        self._log_debug = log_debug
+
+    def _do_log_debug(self, msg: str, *args: t.Any) -> None:
+        if self._log_debug:
+            self._log_debug(msg, *args)
+
+    def copy(self, from_path: StrPath, to_path: StrPath) -> None:
+        """
+        Copy a directory ``from_path`` to a destination ``to_path``.
+
+        ``to_path`` must not exist, but its parent directory must exist.
+        """
+        self._do_log_debug(
+            "Copying complete directory from {!r} to {!r}", from_path, to_path
+        )
+        shutil.copytree(from_path, to_path, symlinks=True)
+
+
+class GitCopier(Copier):
+    """
+    Allows to copy directories that are part of a Git repository.
+    """
+
+    def __init__(
+        self,
+        *,
+        git_bin_path: StrPath = "git",
+        log_debug: t.Callable[[str], None] | None = None,
+    ):
+        super().__init__(log_debug=log_debug)
+        self.git_bin_path = git_bin_path
+
+    def copy(self, from_path: StrPath, to_path: StrPath) -> None:
+        self._do_log_debug("Identifying files not ignored by Git in {!r}", from_path)
+        try:
+            files = list_git_files(
+                from_path, git_bin_path=self.git_bin_path, log_debug=self._log_debug
+            )
+        except ValueError as exc:
+            raise CopierError(
+                f"Error while listing files not ignored by Git in {from_path}: {exc}"
+            ) from exc
+
+        self._do_log_debug(
+            "Copying {} file(s) from {!r} to {!r}", len(files), from_path, to_path
+        )
+        os.mkdir(to_path, mode=0o700)
+        created_directories = set()
+        for file in files:
+            # Decode filename and check whether the file still exists
+            # (deleted files are part of the output)
+            file_decoded = file.decode("utf-8")
+            src_path = os.path.join(from_path, file_decoded)
+            if not os.path.exists(src_path):
+                continue
+
+            # Check whether the directory for this file exists
+            directory, _ = os.path.split(file_decoded)
+            if directory not in created_directories:
+                os.makedirs(os.path.join(to_path, directory), mode=0o700, exist_ok=True)
+                created_directories.add(directory)
+
+            # Copy the file
+            dst_path = os.path.join(to_path, file_decoded)
+            shutil.copyfile(src_path, dst_path)
+
+
+class CollectionCopier:
+    """
+    Creates a copy of a collection to a place where ``--playbook-dir`` can be used
+    to prefer this copy of the collection over any installed ones.
+    """
+
+    def __init__(
+        self,
+        *,
+        source_directory: str,
+        namespace: str,
+        name: str,
+        copier: Copier,
+        log_debug: t.Callable[[str], None] | None = None,
+    ):
+        self.source_directory = source_directory
+        self.namespace = namespace
+        self.name = name
+        self.copier = copier
+        self._log_debug = log_debug
+
+        self.dir = os.path.realpath(tempfile.mkdtemp(prefix="antsibull-fileutils"))
+
+    def _do_log_debug(self, msg: str, *args: t.Any) -> None:
+        if self._log_debug:
+            self._log_debug(msg, *args)
+
+    def __enter__(self) -> tuple[str, str]:
+        try:
+            collection_container_dir = os.path.join(
+                self.dir, "collections", "ansible_collections", self.namespace
+            )
+            os.makedirs(collection_container_dir)
+
+            collection_dir = os.path.join(collection_container_dir, self.name)
+            self._do_log_debug("Temporary collection directory: {!r}", collection_dir)
+
+            self.copier.copy(self.source_directory, collection_dir)
+
+            self._do_log_debug("Temporary collection directory has been populated")
+            return (
+                self.dir,
+                collection_dir,
+            )
+        except Exception:
+            shutil.rmtree(self.dir, ignore_errors=True)
+            raise
+
+    def __exit__(self, type_, value, traceback_):
+        shutil.rmtree(self.dir, ignore_errors=True)

antsibull_fileutils/hashing.py

@@ -0,0 +1,86 @@
+# Author: Toshio Kuratomi <tkuratom@redhat.com>
+# 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: 2020, Ansible Project
+"""Functions to help with hashing."""
+
+from __future__ import annotations
+
+import dataclasses
+import hashlib
+import typing as t
+from collections.abc import Mapping
+
+import aiofiles
+
+if t.TYPE_CHECKING:
+    from _typeshed import StrOrBytesPath
+
+
+@dataclasses.dataclass(frozen=True)
+class _AlgorithmData:
+    name: str
+    algorithm: str
+    kwargs: dict[str, t.Any]
+
+
+_PREFERRED_HASHES: tuple[_AlgorithmData, ...] = (
+    # https://pypi.org/help/#verify-hashes, https://github.com/pypi/warehouse/issues/9628
+    _AlgorithmData(name="sha256", algorithm="sha256", kwargs={}),
+    _AlgorithmData(name="blake2b_256", algorithm="blake2b", kwargs={"digest_size": 32}),
+)
+
+
+async def verify_hash(
+    filename: StrOrBytesPath,
+    hash_digest: str,
+    *,
+    algorithm: str = "sha256",
+    algorithm_kwargs: dict[str, t.Any] | None = None,
+    chunksize: int,
+) -> bool:
+    """
+    Verify whether a file has a given sha256sum.
+
+    :arg filename: The file to verify the sha256sum of.
+    :arg hash_digest: The hash that is expected.
+    :kwarg algorithm: The hash algorithm to use.  This must be present in hashlib on this
+        system.  The default is 'sha256'
+    :kwarg algorithm_kwargs: Parameters to provide to the hash algorithm's constructor.
+    :returns: True if the hash matches, otherwise False.
+    """
+    hasher = getattr(hashlib, algorithm)(**(algorithm_kwargs or {}))
+    async with aiofiles.open(filename, "rb") as f:
+        while chunk := await f.read(chunksize):
+            hasher.update(chunk)
+    if hasher.hexdigest() != hash_digest:
+        return False
+
+    return True
+
+
+async def verify_a_hash(
+    filename: StrOrBytesPath,
+    hash_digests: Mapping[str, str],
+    *,
+    chunksize: int,
+) -> bool:
+    """
+    Verify whether a file has a given hash, given a set of digests with different algorithms.
+    Will only test trustworthy hashes and return ``False`` if none matches.
+
+    :arg filename: The file to verify the hash of.
+    :arg hash_digest: A mapping of hash types to digests.
+    :returns: True if the hash matches, otherwise False.
+    """
+    for algorithm_data in _PREFERRED_HASHES:
+        if algorithm_data.name in hash_digests:
+            return await verify_hash(
+                filename,
+                hash_digests[algorithm_data.name],
+                algorithm=algorithm_data.algorithm,
+                algorithm_kwargs=algorithm_data.kwargs,
+                chunksize=chunksize,
+            )
+    return False

antsibull_fileutils/io.py

@@ -0,0 +1,119 @@
+# Author: Toshio Kuratomi <tkuratom@redhat.com>
+# 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: 2021, Ansible Project
+"""I/O helper functions."""
+
+from __future__ import annotations
+
+import os
+import os.path
+import typing as t
+
+import aiofiles
+
+if t.TYPE_CHECKING:
+    from _typeshed import StrOrBytesPath
+
+
+async def copy_file(
+    source_path: StrOrBytesPath,
+    dest_path: StrOrBytesPath,
+    *,
+    check_content: bool = True,
+    file_check_content: int = 0,
+    chunksize: int,
+) -> bool:
+    """
+    Copy content from one file to another.
+
+    :arg source_path: Source path. Must be a file.
+    :arg dest_path: Destination path.
+    :kwarg check_content: If ``True`` (default) and ``file_check_content > 0`` and the
+        destination file exists, first check whether source and destination are potentially equal
+        before actually copying,
+    :return: ``True`` if the file was actually copied.
+    """
+    if check_content and file_check_content > 0:
+        # Check whether the destination file exists and has the same content as the source file,
+        # in which case we won't overwrite the destination file
+        try:
+            stat_d = os.stat(dest_path)
+            if stat_d.st_size <= file_check_content:
+                stat_s = os.stat(source_path)
+                if stat_d.st_size == stat_s.st_size:
+                    # Read both files and compare
+                    async with aiofiles.open(source_path, "rb") as f_in:
+                        content_to_copy = await f_in.read()
+                    async with aiofiles.open(dest_path, "rb") as f_in:
+                        existing_content = await f_in.read()
+                    if content_to_copy == existing_content:
+                        return False
+                    # Since we already read the contents of the file to copy, simply write it to
+                    # the destination instead of reading it again
+                    async with aiofiles.open(dest_path, "wb") as f_out:
+                        await f_out.write(content_to_copy)
+                    return True
+        except FileNotFoundError:
+            # Destination (or source) file does not exist
+            pass
+
+    async with aiofiles.open(source_path, "rb") as f_in:
+        async with aiofiles.open(dest_path, "wb") as f_out:
+            while chunk := await f_in.read(chunksize):
+                await f_out.write(chunk)
+    return True
+
+
+async def write_file(
+    filename: StrOrBytesPath,
+    content: str,
+    *,
+    file_check_content: int = 0,
+    encoding: str = "utf-8",
+) -> bool:
+    """
+    Write encoded content to file.
+
+    :arg filename: The filename to write to.
+    :arg content: The content to write to the file.
+    :kwarg file_check_content: If > 0 and the file exists and its size in bytes does not exceed this
+        value, will read the file and compare it to the encoded content before overwriting.
+    :return: ``True`` if the file was actually written.
+    """
+
+    content_bytes = content.encode(encoding)
+
+    print(file_check_content, len(content_bytes))
+    if file_check_content > 0 and len(content_bytes) <= file_check_content:
+        # Check whether the destination file exists and has the same content as the one we want to
+        # write, in which case we won't overwrite the file
+        try:
+            stat = os.stat(filename)
+            if stat.st_size == len(content_bytes):
+                # Read file and compare
+                async with aiofiles.open(filename, "rb") as f:
+                    existing_content = await f.read()
+                if existing_content == content_bytes:
+                    return False
+        except FileNotFoundError:
+            # Destination file does not exist
+            pass
+
+    async with aiofiles.open(filename, "wb") as f:
+        await f.write(content_bytes)
+    return True
+
+
+async def read_file(filename: StrOrBytesPath, *, encoding: str = "utf-8") -> str:
+    """
+    Read the file and decode its contents with the given encoding.
+
+    :arg filename: The filename to read from.
+    :kwarg encoding: The encoding to use.
+    """
+    async with aiofiles.open(filename, "r", encoding=encoding) as f:
+        content = await f.read()
+
+    return content

antsibull_fileutils/vcs.py

@@ -0,0 +1,102 @@
+# 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: 2024, Ansible Project
+
+"""
+Git functions.
+"""
+
+from __future__ import annotations
+
+import subprocess
+import typing as t
+
+if t.TYPE_CHECKING:
+    from _typeshed import StrPath
+
+
+def detect_vcs(
+    path: StrPath,
+    *,
+    git_bin_path: StrPath = "git",
+    log_debug: t.Callable[[str], None] | None = None,
+    log_info: t.Callable[[str], None] | None = None,
+) -> t.Literal["none", "git"]:
+    """
+    Try to detect whether the given ``path`` is part of a VCS repository.
+
+    NOTE: The return type might be extended in the future. To be on the safe
+          side, test for the types you support, and use a fallback for unknown
+          values (treat them like ``"none"``).
+    """
+
+    def do_log_debug(msg: str, *args: t.Any) -> None:
+        if log_debug:
+            log_debug(msg, *args)
+
+    def do_log_info(msg: str, *args: t.Any) -> None:
+        if log_info:
+            log_info(msg, *args)
+
+    do_log_debug("Trying to determine whether {!r} is a Git repository", path)
+    try:
+        result = subprocess.check_output(
+            [str(git_bin_path), "-C", path, "rev-parse", "--is-inside-work-tree"],
+            text=True,
+            encoding="utf-8",
+        ).strip()
+        do_log_debug("Git output: {}", result)
+        if result == "true":
+            do_log_info("Identified {!r} as a Git repository", path)
+            return "git"
+    except subprocess.CalledProcessError as exc:
+        # This is likely not inside a work tree
+        do_log_debug("Git failed: {}", exc)
+    except FileNotFoundError as exc:
+        # Cannot find git executable
+        do_log_debug("Cannot find git: {}", exc)
+
+    # Fallback: no VCS detected
+    do_log_debug("Cannot identify VCS")
+    return "none"
+
+
+def list_git_files(
+    directory: StrPath,
+    *,
+    git_bin_path: StrPath = "git",
+    log_debug: t.Callable[[str], None] | None = None,
+) -> list[bytes]:
+    """
+    List all files not ignored by git in a directory and subdirectories.
+
+    Raises ``ValueError`` in case of errors.
+    """
+
+    def do_log_debug(msg: str, *args) -> None:
+        if log_debug:
+            log_debug(msg, *args)
+
+    do_log_debug("Identifying files not ignored by Git in {!r}", directory)
+    try:
+        result = subprocess.check_output(
+            [
+                str(git_bin_path),
+                "ls-files",
+                "-z",
+                "--cached",
+                "--others",
+                "--exclude-standard",
+                "--deduplicate",
+            ],
+            cwd=directory,
+        ).strip(b"\x00")
+        if result == b"":
+            return []
+        return result.split(b"\x00")
+    except subprocess.CalledProcessError as exc:
+        raise ValueError("Error while running git") from exc
+    except FileNotFoundError as exc:
+        raise ValueError("Cannot find git executable") from exc

antsibull_fileutils/yaml.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: 2021, Ansible Project
+
+"""
+YAML handling.
+"""
+
+from __future__ import annotations
+
+import typing as t
+
+import yaml
+
+_SafeLoader: t.Any
+_SafeDumper: t.Any
+try:
+    # use C version if possible for speedup
+    from yaml import CSafeDumper as _SafeDumper
+    from yaml import CSafeLoader as _SafeLoader
+except ImportError:  # pragma: no cover
+    from yaml import SafeDumper as _SafeDumper
+    from yaml import SafeLoader as _SafeLoader
+
+if t.TYPE_CHECKING:
+    from _typeshed import StrOrBytesPath, SupportsWrite
+
+
+class _IndentedDumper(yaml.SafeDumper):
+    """
+    Extend YAML dumper to increase indent of list items.
+    """
+
+    def increase_indent(self, flow=False, indentless=False):
+        return super().increase_indent(flow, False)
+
+
+def load_yaml_bytes(data: bytes) -> t.Any:
+    """
+    Load and parse YAML from given bytes.
+    """
+    return yaml.load(data, Loader=_SafeLoader)
+
+
+def load_yaml_file(path: StrOrBytesPath) -> t.Any:
+    """
+    Load and parse YAML file ``path``.
+    """
+    with open(path, "rb") as stream:
+        return yaml.load(stream, Loader=_SafeLoader)
+
+
+def store_yaml_file(
+    path: StrOrBytesPath, content: t.Any, *, nice: bool = False, sort_keys: bool = True
+) -> None:
+    """
+    Store ``content`` as YAML file under ``path``.
+    """
+    with open(path, "wb") as stream:
+        store_yaml_stream(stream, content, nice=nice, sort_keys=sort_keys)
+
+
+def store_yaml_stream(
+    stream: SupportsWrite, content: t.Any, *, nice: bool = False, sort_keys: bool = True
+) -> None:
+    """
+    Dump ``content`` as YAML to an IO ``stream``.
+    """
+    dumper = _IndentedDumper if nice else _SafeDumper
+    dumper.ignore_aliases = lambda *args: True
+    yaml.dump(
+        content,
+        stream,
+        default_flow_style=False,
+        encoding="utf-8",
+        Dumper=dumper,
+        explicit_start=nice,
+        sort_keys=sort_keys,
+    )

antsibull_fileutils-1.0.0.dist-info/METADATA

@@ -0,0 +1,129 @@
+Metadata-Version: 2.3
+Name: antsibull-fileutils
+Version: 1.0.0
+Summary: Tools for building the Ansible Distribution
+Project-URL: Source code, https://github.com/ansible-community/antsibull-fileutils
+Project-URL: Code of Conduct, https://docs.ansible.com/ansible/latest/community/code_of_conduct.html
+Project-URL: Bug tracker, https://github.com/ansible-community/antsibull-fileutils/issues
+Author-email: Felix Fontein <felix@fontein.de>
+Maintainer-email: Felix Fontein <felix@fontein.de>, Maxwell G <maxwell@gtmx.me>
+License-Expression: GPL-3.0-or-later AND BSD-2-Clause AND MIT AND PSF-2.0
+License-File: LICENSES/GPL-3.0-or-later.txt
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: Ansible
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Requires-Dist: aiofiles
+Requires-Dist: pyyaml
+Provides-Extra: codeqa
+Requires-Dist: antsibull-changelog; extra == 'codeqa'
+Requires-Dist: flake8>=6.0.0; extra == 'codeqa'
+Requires-Dist: pylint>=2.15.7; extra == 'codeqa'
+Requires-Dist: reuse; extra == 'codeqa'
+Provides-Extra: coverage
+Requires-Dist: coverage[toml]; extra == 'coverage'
+Provides-Extra: dev
+Requires-Dist: antsibull-changelog; extra == 'dev'
+Requires-Dist: black>=24; extra == 'dev'
+Requires-Dist: coverage[toml]; extra == 'dev'
+Requires-Dist: flake8>=6.0.0; extra == 'dev'
+Requires-Dist: isort; extra == 'dev'
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: nox; extra == 'dev'
+Requires-Dist: pylint>=2.15.7; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.20; extra == 'dev'
+Requires-Dist: pytest-cov; extra == 'dev'
+Requires-Dist: pytest-error-for-skips; extra == 'dev'
+Requires-Dist: reuse; extra == 'dev'
+Requires-Dist: types-aiofiles; extra == 'dev'
+Requires-Dist: types-pyyaml; extra == 'dev'
+Requires-Dist: typing-extensions; extra == 'dev'
+Provides-Extra: formatters
+Requires-Dist: black>=24; extra == 'formatters'
+Requires-Dist: isort; extra == 'formatters'
+Provides-Extra: test
+Requires-Dist: pytest; extra == 'test'
+Requires-Dist: pytest-asyncio>=0.20; extra == 'test'
+Requires-Dist: pytest-cov; extra == 'test'
+Requires-Dist: pytest-error-for-skips; extra == 'test'
+Provides-Extra: typing
+Requires-Dist: mypy; extra == 'typing'
+Requires-Dist: types-aiofiles; extra == 'typing'
+Requires-Dist: types-pyyaml; extra == 'typing'
+Requires-Dist: typing-extensions; extra == 'typing'
+Description-Content-Type: text/markdown
+
+<!--
+Copyright (c) Ansible Project
+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
+-->
+
+# antsibull-fileutils -- File Utility Library for Community Ansible Tools
+[![Discuss on Matrix at #antsibull:ansible.com](https://img.shields.io/matrix/antsibull:ansible.com.svg?server_fqdn=ansible-accounts.ems.host&label=Discuss%20on%20Matrix%20at%20%23antsibull:ansible.com&logo=matrix)](https://matrix.to/#/#antsibull:ansible.com)
+[![Nox badge](https://github.com/ansible-community/antsibull-fileutils/actions/workflows/nox.yml/badge.svg)](https://github.com/ansible-community/antsibull-fileutils/actions/workflows/nox.yml)
+[![Codecov badge](https://img.shields.io/codecov/c/github/ansible-community/antsibull-fileutils)](https://codecov.io/gh/ansible-community/antsibull-fileutils)
+[![REUSE status](https://api.reuse.software/badge/github.com/ansible-community/antsibull-fileutils)](https://api.reuse.software/info/github.com/ansible-community/antsibull-fileutils)
+
+This library provides file utils needed by community Ansible tooling.
+
+You can find a list of changes in [the antsibull-fileutils changelog](./CHANGELOG.rst).
+
+Unless otherwise noted in the code, it is licensed under the terms of the GNU
+General Public License v3 or, at your option, later.
+
+antsibull-fileutils is covered by the [Ansible Code of Conduct](https://docs.ansible.com/ansible/latest/community/code_of_conduct.html).
+
+## Versioning and compatibility
+
+From version 1.0.0 on, antsibull-fileutils sticks to semantic versioning and aims at providing no backwards compatibility breaking changes during a major release cycle. We might make exceptions from this in case of security fixes for vulnerabilities that are severe enough.
+
+The current development version is 1.x.y. 1.x.y is developed on the `main` branch.
+
+## Development
+
+Install and run `nox` to run all tests. That's it for simple contributions!
+`nox` will create virtual environments in `.nox` inside the checked out project
+and install the requirements needed to run the tests there.
+
+To run specific tests:
+
+1. `nox -e test` to only run unit tests;
+2. `nox -e coverage` to display combined coverage results after running `nox -e
+   test`;
+3. `nox -e lint` to run all linters and formatters at once;
+4. `nox -e formatters` to run `isort` and `black`;
+3. `nox -e codeqa` to run `flake8`, `pylint`, `reuse lint`, and `antsibull-changelog lint`;
+6. `nox -e typing` to run `mypy` and `pyre`
+
+## Creating a new release:
+
+1. Run `nox -e bump -- <version> <release_summary_message>`. This:
+   * Bumps the package version in `src/antsibull_fileutils/__init__.py`.
+   * Creates `changelogs/fragments/<version>.yml` with a `release_summary` section.
+   * Runs `antsibull-changelog release` and adds the changed files to git.
+   * Commits with message `Release <version>.` and runs `git tag -a -m 'antsibull-fileutils <version>' <version>`.
+   * Runs `hatch build`.
+2. Run `git push` to the appropriate remotes.
+3. Once CI passes on GitHub, run `nox -e publish`. This:
+   * Runs `hatch publish`;
+   * Bumps the version to `<version>.post0`;
+   * Adds the changed file to git and run `git commit -m 'Post-release version bump.'`;
+4. Run `git push --follow-tags` to the appropriate remotes and create a GitHub release.
+
+## License
+
+Unless otherwise noted in the code, it is licensed under the terms of the GNU
+General Public License v3 or, at your option, later. See
+[LICENSES/GPL-3.0-or-later.txt](https://github.com/ansible-community/antsibull-changelog/tree/main/LICENSE)
+for a copy of the license.
+
+The repository follows the [REUSE Specification](https://reuse.software/spec/) for declaring copyright and
+licensing information. The only exception are changelog fragments in ``changelog/fragments/``.