implement detailed build plan

This commit is contained in:
arcanis committed 2026-11-12 18:30:40 +02:00
1 parent dc4f2be65b
commit 9697281a0e
19 files changed
+502 -79

No files matched your search

@@ -21,8 +21,8 @@ from collections.abc import Callable, Iterable
from ahriman.application.application.application_packages import ApplicationPackages from ahriman.application.application.application_packages import ApplicationPackages
from ahriman.application.application.application_repository import ApplicationRepository from ahriman.application.application.application_repository import ApplicationRepository
from ahriman.core.formatters import UpdatePrinter from ahriman.core.formatters import BuildPlanPrinter
from ahriman.core.tree import Tree from ahriman.models.build_plan import BuildPlan, BuildPlanReason
from ahriman.models.package import Package from ahriman.models.package import Package
from ahriman.models.result import Result from ahriman.models.result import Result
@@ -95,45 +95,41 @@ class Application(ApplicationPackages, ApplicationRepository):
""" """
self.repository.triggers.on_stop() self.repository.triggers.on_stop()
def print_updates(self, packages: list[Package], *, log_fn: Callable[[str], None]) -> None: def print_updates(self, plan: BuildPlan, *, log_fn: Callable[[str], None], bump_pkgrel: bool = True) -> None:
""" """
print list of packages to be built. This method will build dependency tree and print updates accordingly print packages and their reasons, grouped by dependency step
Args: Args:
packages(list[Package]): package list to be printed plan(BuildPlan): packages and selection reasons to be printed
log_fn(Callable[[str], None]): logger function to log updates log_fn(Callable[[str], None]): logger function to log updates
bump_pkgrel(bool, optional): whether duplicate releases are expected to increment
""" """
local_versions = {package.base: package.version for package in self.repository.packages()} local_versions = {package.base: package.version for package in self.repository.packages()}
BuildPlanPrinter(plan, local_versions, bump_pkgrel=bump_pkgrel)(verbose=True, log_fn=log_fn)
tree = Tree.resolve(packages) def with_dependencies(self, plan: BuildPlan, *, process_dependencies: bool) -> BuildPlan:
for level in tree:
for package in level:
UpdatePrinter(package, local_versions.get(package.base))(verbose=True, log_fn=log_fn, separator=" -> ")
def with_dependencies(self, packages: list[Package], *, process_dependencies: bool) -> list[Package]:
""" """
add missing dependencies to list of packages. This will extract known packages, check dependencies of add missing dependencies to a build plan and record which packages require them
the supplied packages and add packages which are not presented in the list of known packages.
Args: Args:
packages(list[Package]): list of source packages of which dependencies have to be processed plan(BuildPlan): selected packages and their reasons
process_dependencies(bool): if set to ``False``, dependencies will not be processed process_dependencies(bool): if set to ``False``, dependencies will not be processed
Returns: Returns:
list[Package]: updated packages list. Packager for dependencies will be copied from the original package BuildPlan: selected packages and their dependencies
Examples: Examples:
In the most cases, in order to avoid build failure, it is required to add missing packages, which can be In the most cases, in order to avoid build failure, it is required to add missing packages, which can be
done by calling:: done by calling::
>>> application = ... >>> application = ...
>>> packages = application.with_dependencies(packages, process_dependencies=True) >>> plan = application.with_dependencies(plan, process_dependencies=True)
>>> application.print_updates(packages, log_fn=print) >>> application.update(plan.packages)
""" """
if not process_dependencies or not packages: if not process_dependencies or not plan:
return packages return plan
def missing_dependencies(sources: Iterable[Package]) -> dict[str, str | None]: def missing_dependencies(sources: Iterable[Package]) -> dict[str, tuple[str | None, str]]:
# append list of known packages with packages which are in current sources # append list of known packages with packages which are in current sources
satisfied_packages = known_packages | { satisfied_packages = known_packages | {
single single
@@ -142,35 +138,38 @@ class Application(ApplicationPackages, ApplicationRepository):
} }
return { return {
dependency: source.packager dependency: (source.packager, source.base)
for source in sources for source in sources
for dependency in source.depends_build for dependency in source.depends_build
if dependency not in satisfied_packages if dependency not in satisfied_packages
} }
def new_packages(root: Package) -> dict[str, Package]: def new_packages(root: Package) -> dict[str, tuple[Package, str]]:
portion = {root.base: root} portion = {root.base: (root, root.base)}
while missing := missing_dependencies(portion.values()): while missing := missing_dependencies(package for package, _ in portion.values()):
for package_name, packager in missing.items(): for package_name, (packager, requester) in missing.items():
if (source_dir := self.repository.paths.cache_for(package_name)).is_dir(): if (source_dir := self.repository.paths.cache_for(package_name)).is_dir():
# there is local cache, load package from it # there is local cache, load package from it
leaf = Package.from_build(source_dir, self.repository.repository_id.architecture, packager) leaf = Package.from_build(source_dir, self.repository.repository_id.architecture, packager)
else: else:
leaf = Package.from_aur(package_name, packager, include_provides=True) leaf = Package.from_aur(package_name, packager, include_provides=True)
portion[leaf.base] = leaf portion[leaf.base] = leaf, requester
# register package in the database # register package in the database
self.reporter.set_unknown(leaf) self.reporter.set_unknown(leaf)
return portion return {base: item for base, item in portion.items() if base != root.base}
known_packages = self._known_packages() known_packages = self._known_packages()
with_dependencies: dict[str, Package] = {} for package in plan.packages:
for package in packages:
with self.in_package_context(package.base, package.version): # use the same context for the logger with self.in_package_context(package.base, package.version): # use the same context for the logger
try: try:
with_dependencies |= new_packages(package) portion = new_packages(package)
except Exception: except Exception:
self.logger.exception("could not process dependencies of %s, skip the package", package.base) self.logger.exception("could not process dependencies of %s, skip the package", package.base)
continue
return list(with_dependencies.values()) for dependency, requester in portion.values():
plan.add(dependency, BuildPlanReason.RequiredBy, requester=requester)
return plan
@@ -23,6 +23,7 @@ from ahriman.application.application.application_properties import ApplicationPr
from ahriman.application.application.workers import Updater from ahriman.application.application.workers import Updater
from ahriman.core.build_tools.sources import Sources from ahriman.core.build_tools.sources import Sources
from ahriman.core.exceptions import UnknownPackageError from ahriman.core.exceptions import UnknownPackageError
from ahriman.models.build_plan import BuildPlan, BuildPlanReason
from ahriman.models.package import Package from ahriman.models.package import Package
from ahriman.models.packagers import Packagers from ahriman.models.packagers import Packagers
from ahriman.models.result import Result from ahriman.models.result import Result
@@ -182,7 +183,7 @@ class ApplicationRepository(ApplicationProperties):
return result return result
def updates(self, filter_packages: Iterable[str], *, def updates(self, filter_packages: Iterable[str], *,
aur: bool, local: bool, manual: bool, vcs: bool, check_files: bool) -> list[Package]: aur: bool, local: bool, manual: bool, vcs: bool, check_files: bool) -> BuildPlan:
""" """
get list of packages to run update process get list of packages to run update process
@@ -193,25 +194,22 @@ class ApplicationRepository(ApplicationProperties):
manual(bool): include or exclude manual updates manual(bool): include or exclude manual updates
vcs(bool): enable or disable checking of VCS packages vcs(bool): enable or disable checking of VCS packages
check_files(bool): check for broken dependencies check_files(bool): check for broken dependencies
Returns: Returns:
list[Package]: list of out-of-dated packages BuildPlan: selected packages and their reasons
""" """
updates = {} plan = BuildPlan()
# always add already built packages, because they will be always added # always add already built packages, because they will be always added
updates.update({ built = self.repository.load_archives(self.repository.packages_built())
package.base: package for package in built:
for package in self.repository.load_archives(self.repository.packages_built()) plan.add(package, BuildPlanReason.AlreadyBuilt)
})
if aur: if aur:
updates.update({package.base: package for package in self.repository.updates_aur(filter_packages, vcs=vcs)}) self.repository.updates_aur(filter_packages, vcs=vcs, plan=plan)
if local: if local:
updates.update({package.base: package for package in self.repository.updates_local(vcs=vcs)}) self.repository.updates_local(vcs=vcs, plan=plan)
if manual: if manual:
updates.update({package.base: package for package in self.repository.updates_manual()}) self.repository.updates_manual(plan=plan)
if check_files: if check_files:
updates.update({package.base: package for package in self.repository.updates_dependencies(filter_packages)}) self.repository.updates_dependencies(filter_packages, plan=plan)
return plan
return [package for _, package in sorted(updates.items())]
@@ -23,6 +23,7 @@ from ahriman.application.application import Application
from ahriman.application.handlers.handler import Handler, SubParserAction from ahriman.application.handlers.handler import Handler, SubParserAction
from ahriman.core.configuration import Configuration from ahriman.core.configuration import Configuration
from ahriman.core.utils import extract_user from ahriman.core.utils import extract_user
from ahriman.models.build_plan import BuildPlan, BuildPlanReason
from ahriman.models.build_status import BuildStatusEnum from ahriman.models.build_status import BuildStatusEnum
from ahriman.models.package import Package from ahriman.models.package import Package
from ahriman.models.packagers import Packagers from ahriman.models.packagers import Packagers
@@ -54,7 +55,10 @@ class Rebuild(Handler):
Rebuild.check_status(args.exit_code, packages) Rebuild.check_status(args.exit_code, packages)
if args.dry_run: if args.dry_run:
application.print_updates(packages, log_fn=print) plan = BuildPlan()
for package in packages:
plan.add(package, BuildPlanReason.Rebuild)
application.print_updates(plan, log_fn=print)
return return
result = application.update(packages, Packagers(args.username), bump_pkgrel=args.increment) result = application.update(packages, Packagers(args.username), bump_pkgrel=args.increment)
@@ -147,19 +147,23 @@ class Update(Handler):
application(Application): application instance application(Application): application instance
args(argparse.Namespace): command line args args(argparse.Namespace): command line args
""" """
packages = application.updates(args.package, aur=args.aur, local=args.local, manual=args.manual, vcs=args.vcs, plan = application.updates(
check_files=args.check_files) args.package, aur=args.aur, local=args.local, manual=args.manual, vcs=args.vcs,
check_files=args.check_files)
packages = plan.packages
if args.changes: # generate changes if requested if args.changes: # generate changes if requested
application.changes(packages) application.changes(packages)
plan = application.with_dependencies(plan, process_dependencies=args.dependencies and not args.dry_run)
packages = plan.packages
if args.dry_run: # exit from application if no build requested if args.dry_run: # exit from application if no build requested
Update.check_status(args.exit_code, packages) # status code check Update.check_status(args.exit_code, packages) # status code check
application.print_updates(plan, log_fn=print, bump_pkgrel=args.increment)
return return
packages = application.with_dependencies(packages, process_dependencies=args.dependencies)
packagers = Packagers(args.username, {package.base: package.packager for package in packages}) packagers = Packagers(args.username, {package.base: package.packager for package in packages})
application.print_updates(packages, log_fn=application.logger.info) application.print_updates(plan, log_fn=application.logger.info, bump_pkgrel=args.increment)
result = application.update(packages, packagers, bump_pkgrel=args.increment) result = application.update(packages, packagers, bump_pkgrel=args.increment)
Update.check_status(args.exit_code, not result.is_empty) Update.check_status(args.exit_code, not result.is_empty)
@@ -18,6 +18,7 @@
# along with this program. If not, see <http://www.gnu.org/licenses/>. # along with this program. If not, see <http://www.gnu.org/licenses/>.
# #
from ahriman.core.formatters.aur_printer import AurPrinter from ahriman.core.formatters.aur_printer import AurPrinter
from ahriman.core.formatters.build_plan_printer import BuildPlanPrinter
from ahriman.core.formatters.build_printer import BuildPrinter from ahriman.core.formatters.build_printer import BuildPrinter
from ahriman.core.formatters.changes_printer import ChangesPrinter from ahriman.core.formatters.changes_printer import ChangesPrinter
from ahriman.core.formatters.configuration_paths_printer import ConfigurationPathsPrinter from ahriman.core.formatters.configuration_paths_printer import ConfigurationPathsPrinter
@@ -0,0 +1,70 @@
#
# Copyright (c) 2021-2026 ahriman team.
#
# This file is part of ahriman
# (see https://github.com/arcan1s/ahriman).
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
from ahriman.core.formatters.printer import Printer
from ahriman.core.formatters.update_printer import UpdatePrinter
from ahriman.core.tree import Tree
from ahriman.models.build_plan import BuildPlan, BuildPlanReason
from ahriman.models.property import Property
class BuildPlanPrinter(Printer):
"""
print packages and their selection reasons
Attributes:
plan(BuildPlan): plan to display
local_versions(dict[str, str]): published package versions indexed by base
bump_pkgrel(bool): whether duplicate package releases are expected to increment
"""
def __init__(self, plan: BuildPlan, local_versions: dict[str, str], *, bump_pkgrel: bool = False) -> None:
"""
Args:
plan(BuildPlan): plan to display
local_versions(dict[str, str]): published package versions indexed by base
bump_pkgrel(bool, optional): show an expected release increment (Default value = False)
"""
self.plan = plan
self.local_versions = local_versions
self.bump_pkgrel = bump_pkgrel
def properties(self) -> list[Property]:
"""
convert the plan into printable lines
Returns:
list[Property]: plan output lines
"""
if not self.plan.items:
return [Property("", "No packages selected", is_required=True, indent=0)]
properties: list[Property] = []
for level in Tree.resolve(self.plan.packages):
for package in level:
update = UpdatePrinter(
package, self.local_versions.get(package.base), bump_pkgrel=self.bump_pkgrel).properties()[0]
properties.append(Property(
package.base, f"{update.name} -> {update.value}", is_required=True, indent=0))
item = self.plan.item(package.base)
reason = item.reason.value
if item.requester is not None:
reason = f"{BuildPlanReason.RequiredBy.value} {item.requester}"
properties.append(Property("Reason", reason, indent=1))
return properties
@@ -32,15 +32,17 @@ class UpdatePrinter(StringPrinter):
local_version(str | None): local version of the package if any local_version(str | None): local version of the package if any
""" """
def __init__(self, remote: Package, local_version: str | None) -> None: def __init__(self, remote: Package, local_version: str | None, *, bump_pkgrel: bool = True) -> None:
""" """
Args: Args:
remote(Package): remote (new) package object remote(Package): remote (new) package object
local_version(str | None): local version of the package if any local_version(str | None): local version of the package if any
bump_pkgrel(bool, optional): show a release increment for duplicates (Default value = True)
""" """
StringPrinter.__init__(self, remote.base) StringPrinter.__init__(self, remote.base)
self.package = remote self.package = remote
self.local_version = local_version self.local_version = local_version
self.bump_pkgrel = bump_pkgrel
def properties(self) -> list[Property]: def properties(self) -> list[Property]:
""" """
@@ -49,7 +51,7 @@ class UpdatePrinter(StringPrinter):
Returns: Returns:
list[Property]: list of content properties list[Property]: list of content properties
""" """
if (pkgrel := self.package.next_pkgrel(self.local_version)) is not None: if self.bump_pkgrel and (pkgrel := self.package.next_pkgrel(self.local_version)) is not None:
epoch, pkgver, _ = parse_version(self.package.version) epoch, pkgver, _ = parse_version(self.package.version)
effective_new_version = full_version(epoch, pkgver, pkgrel) effective_new_version = full_version(epoch, pkgver, pkgrel)
else: else:
@@ -24,6 +24,7 @@ from ahriman.core.build_tools.sources import Sources
from ahriman.core.exceptions import UnknownPackageError from ahriman.core.exceptions import UnknownPackageError
from ahriman.core.repository.cleaner import Cleaner from ahriman.core.repository.cleaner import Cleaner
from ahriman.core.repository.package_info import PackageInfo from ahriman.core.repository.package_info import PackageInfo
from ahriman.models.build_plan import BuildPlan, BuildPlanReason
from ahriman.models.build_status import BuildStatusEnum from ahriman.models.build_status import BuildStatusEnum
from ahriman.models.event import EventType from ahriman.models.event import EventType
from ahriman.models.package import Package from ahriman.models.package import Package
@@ -47,13 +48,14 @@ class UpdateHandler(PackageInfo, Cleaner):
package.base for package, status in self.reporter.package_get(None) if status.is_held package.base for package, status in self.reporter.package_get(None) if status.is_held
} }
def updates_aur(self, filter_packages: Iterable[str], *, vcs: bool) -> list[Package]: def updates_aur(self, filter_packages: Iterable[str], *, vcs: bool, plan: BuildPlan) -> list[Package]:
""" """
check AUR for updates check AUR for updates
Args: Args:
filter_packages(Iterable[str]): do not check every package just specified in the list filter_packages(Iterable[str]): do not check every package just specified in the list
vcs(bool): enable or disable checking of VCS packages vcs(bool): enable or disable checking of VCS packages
plan(BuildPlan): record update reasons for a preview
Returns: Returns:
list[Package]: list of packages which are out-of-dated list[Package]: list of packages which are out-of-dated
@@ -87,6 +89,9 @@ class UpdateHandler(PackageInfo, Cleaner):
self.reporter.set_pending(local.base) self.reporter.set_pending(local.base)
self.event(local.base, EventType.PackageOutdated, "Remote version is newer than local") self.event(local.base, EventType.PackageOutdated, "Remote version is newer than local")
result.append(remote) result.append(remote)
reason = BuildPlanReason.OfficialRepositoryUpdate \
if local.remote.source == PackageSource.Repository else BuildPlanReason.AURUpdate
plan.add(remote, reason)
else: else:
self.reporter.package_status_update(local.base, BuildStatusEnum.Success) self.reporter.package_status_update(local.base, BuildStatusEnum.Success)
except Exception: except Exception:
@@ -95,13 +100,14 @@ class UpdateHandler(PackageInfo, Cleaner):
return result return result
def updates_dependencies(self, filter_packages: Iterable[str]) -> list[Package]: def updates_dependencies(self, filter_packages: Iterable[str], *, plan: BuildPlan) -> list[Package]:
""" """
check packages which are required to be rebuilt based on dynamic dependencies check packages which are required to be rebuilt based on dynamic dependencies
(e.g. linking, modules paths, etc.) (e.g. linking, modules paths, etc.)
Args: Args:
filter_packages(Iterable[str]): do not check every package just specified in the list filter_packages(Iterable[str]): do not check every package just specified in the list
plan(BuildPlan): record dependency reasons for a preview
Returns: Returns:
list[Package]: list of packages for which there is breaking linking list[Package]: list of packages for which there is breaking linking
@@ -138,17 +144,19 @@ class UpdateHandler(PackageInfo, Cleaner):
self.reporter.set_pending(local.base) self.reporter.set_pending(local.base)
self.event(local.base, EventType.PackageOutdated, "Implicit dependencies are broken") self.event(local.base, EventType.PackageOutdated, "Implicit dependencies are broken")
result.append(local) result.append(local)
plan.add(local, BuildPlanReason.BrokenImplicitDependency)
break break
return result return result
def updates_local(self, *, vcs: bool) -> list[Package]: def updates_local(self, *, vcs: bool, plan: BuildPlan) -> list[Package]:
""" """
check local packages for updates check local packages for updates
Args: Args:
vcs(bool): enable or disable checking of VCS packages vcs(bool): enable or disable checking of VCS packages
plan(BuildPlan): record update reasons for a preview
Returns: Returns:
list[Package]: list of local packages which are out-of-dated list[Package]: list of local packages which are out-of-dated
@@ -188,12 +196,14 @@ class UpdateHandler(PackageInfo, Cleaner):
self.reporter.set_pending(local.base) self.reporter.set_pending(local.base)
self.event(local.base, EventType.PackageOutdated, "Locally pulled sources are outdated") self.event(local.base, EventType.PackageOutdated, "Locally pulled sources are outdated")
result.append(remote) result.append(remote)
plan.add(remote, BuildPlanReason.LocalSourceUpdate)
except Exception: except Exception:
self.logger.exception("could not process package at %s", cache_dir) self.logger.exception("could not process package at %s", cache_dir)
return result return result
def updates_manual(self) -> list[Package]: def updates_manual(self, *, plan: BuildPlan) -> list[Package]:
""" """
check for packages for which manual update has been requested check for packages for which manual update has been requested
@@ -206,6 +216,7 @@ class UpdateHandler(PackageInfo, Cleaner):
try: try:
for local in self.database.build_queue_get(): for local in self.database.build_queue_get():
result.append(local) result.append(local)
plan.add(local, BuildPlanReason.QueuedRequest)
if local.base not in known_bases: if local.base not in known_bases:
self.reporter.set_unknown(local) self.reporter.set_unknown(local)
else: else:
@@ -0,0 +1,154 @@
#
# Copyright (c) 2021-2026 ahriman team.
#
# This file is part of ahriman
# (see https://github.com/arcan1s/ahriman).
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
from collections.abc import Iterator
from dataclasses import dataclass
from enum import StrEnum
from ahriman.models.package import Package
class BuildPlanReason(StrEnum):
"""
reason why package was selected for a build plan
Attributes:
AlreadyBuilt(BuildPlanReason): package has already been built
AURUpdate(BuildPlanReason): package has an AUR update
OfficialRepositoryUpdate(BuildPlanReason): package has an official repository update
LocalSourceUpdate(BuildPlanReason): locally sourced package has an update
QueuedRequest(BuildPlanReason): package was manually queued
BrokenImplicitDependency(BuildPlanReason): package has a broken implicit dependency
Rebuild(BuildPlanReason): package was selected for rebuild
RequiredBy(BuildPlanReason): package is required by another selected package
"""
AlreadyBuilt = "already built"
AURUpdate = "AUR update"
OfficialRepositoryUpdate = "official repository update"
LocalSourceUpdate = "local source update"
QueuedRequest = "queued request"
BrokenImplicitDependency = "broken implicit dependency"
Rebuild = "rebuild"
RequiredBy = "required by"
@dataclass(frozen=True)
class BuildPlanItem:
"""
one package and the reason it appears in a build plan
Attributes:
package(Package): package selected for the plan
reason(BuildPlanReason): why the package was selected
requester(str | None): package that requires this package
"""
package: Package
reason: BuildPlanReason
requester: str | None = None
class BuildPlan:
"""
in-memory preview of the packages selected for a build operation
"""
def __init__(self) -> None:
"""
initialize an empty build plan
"""
self._items: dict[str, BuildPlanItem] = {}
@property
def items(self) -> list[BuildPlanItem]:
"""
get plan items in stable package-base order
Returns:
list[BuildPlanItem]: selected plan items
"""
return [self._items[base] for base in sorted(self._items)]
@property
def packages(self) -> list[Package]:
"""
get packages in stable package-base order
Returns:
list[Package]: selected packages
"""
return [item.package for item in self.items]
def add(self, package: Package, reason: BuildPlanReason, *, requester: str | None = None) -> BuildPlanItem:
"""
add or update a package in the plan
Args:
package(Package): package selected for the plan
reason(BuildPlanReason): reason for selecting it
requester(str | None, optional): package requiring this dependency
Returns:
BuildPlanItem: plan item for the package
"""
item = self._items[package.base] = BuildPlanItem(package, reason, requester)
return item
def item(self, package_base: str) -> BuildPlanItem:
"""
get a plan item by package base
Args:
package_base(str): package base to look up
Returns:
BuildPlanItem: matching item
"""
return self._items[package_base]
def __contains__(self, item: Package) -> bool:
"""
check whether plan holds a package or not
Args:
item(Package): package to lookup
Returns:
bool: ``True`` in case if the package is already in the plan and ``False`` otherwise
"""
return item.base in self._items
def __iter__(self) -> Iterator[Package]:
"""
iterate over selected packages in stable package-base order
Yields:
Package: selected package
"""
return iter(self.packages)
def __len__(self) -> int:
"""
get number of selected packages
Returns:
int: number of selected packages
"""
return len(self._items)
@@ -5,6 +5,7 @@ from unittest.mock import MagicMock, call as MockCall
from ahriman.application.application import Application from ahriman.application.application import Application
from ahriman.core.tree import Leaf, Tree from ahriman.core.tree import Leaf, Tree
from ahriman.models.build_plan import BuildPlan, BuildPlanReason
from ahriman.models.package import Package from ahriman.models.package import Package
from ahriman.models.result import Result from ahriman.models.result import Result
@@ -59,8 +60,35 @@ def test_print_updates(application: Application, package_ahriman: Package, mocke
mocker.patch("ahriman.core.tree.Tree.resolve", return_value=tree.levels()) mocker.patch("ahriman.core.tree.Tree.resolve", return_value=tree.levels())
print_mock = mocker.patch("ahriman.core.formatters.Printer.print") print_mock = mocker.patch("ahriman.core.formatters.Printer.print")
application.print_updates([package_ahriman], log_fn=print) plan = BuildPlan()
print_mock.assert_called_once_with(verbose=True, log_fn=print, separator=" -> ") plan.add(package_ahriman, BuildPlanReason.AURUpdate)
application.print_updates(plan, log_fn=print)
print_mock.assert_called_once_with(verbose=True, log_fn=print, separator=": ")
def test_print_updates_plan(application: Application, package_ahriman: Package, mocker: MockerFixture) -> None:
"""
print each package version and its selection reason
"""
plan = BuildPlan()
plan.add(package_ahriman, BuildPlanReason.AURUpdate)
mocker.patch("ahriman.core.repository.repository.Repository.packages", return_value=[package_ahriman])
mocker.patch("ahriman.core.tree.Tree.resolve", return_value=[[package_ahriman]])
output: list[str] = []
application.print_updates(plan, log_fn=output.append)
assert output == [f"{package_ahriman.base}: {package_ahriman.version} -> {package_ahriman.version}",
"\tReason: AUR update"]
def test_print_empty_plan(application: Application) -> None:
"""An empty preview explains why it has no package lines."""
output: list[str] = []
application.print_updates(BuildPlan(), log_fn=output.append)
assert output == ["No packages selected"]
def test_with_dependencies(application: Application, package_ahriman: Package, package_python_schedule: Package, def test_with_dependencies(application: Application, package_ahriman: Package, package_python_schedule: Package,
@@ -99,8 +127,13 @@ def test_with_dependencies(application: Application, package_ahriman: Package, p
return_value={"devtools", "python-build", "python-pytest"}) return_value={"devtools", "python-build", "python-pytest"})
status_client_mock = mocker.patch("ahriman.core.status.Client.set_unknown") status_client_mock = mocker.patch("ahriman.core.status.Client.set_unknown")
result = application.with_dependencies([package_ahriman], process_dependencies=True) plan = BuildPlan()
assert {package.base: package for package in result} == packages plan.add(package_ahriman, BuildPlanReason.AURUpdate)
result = application.with_dependencies(plan, process_dependencies=True)
assert result is plan
assert {package.base: package for package in result.packages} == packages
assert result.item(package_ahriman.base).requester is None
assert result.item(package_python_schedule.base).requester == package_ahriman.base
package_aur_mock.assert_has_calls([ package_aur_mock.assert_has_calls([
MockCall(package_python_schedule.base, package_ahriman.packager, include_provides=True), MockCall(package_python_schedule.base, package_ahriman.packager, include_provides=True),
MockCall("python-installer", package_ahriman.packager, include_provides=True), MockCall("python-installer", package_ahriman.packager, include_provides=True),
@@ -120,7 +153,7 @@ def test_with_dependencies(application: Application, package_ahriman: Package, p
def test_with_dependencies_exception(application: Application, package_ahriman: Package, def test_with_dependencies_exception(application: Application, package_ahriman: Package,
package_python_schedule: Package, mocker: MockerFixture) -> None: package_python_schedule: Package, mocker: MockerFixture) -> None:
""" """
must skip packages if exception occurs must keep selected packages if dependency lookup fails
""" """
def create_package_mock(package_base) -> MagicMock: def create_package_mock(package_base) -> MagicMock:
mock = MagicMock() mock = MagicMock()
@@ -148,7 +181,10 @@ def test_with_dependencies_exception(application: Application, package_ahriman:
mocker.patch("ahriman.application.application.Application._known_packages", mocker.patch("ahriman.application.application.Application._known_packages",
return_value={"devtools", "python-build", "python-pytest"}) return_value={"devtools", "python-build", "python-pytest"})
assert not application.with_dependencies([package_ahriman], process_dependencies=True) plan = BuildPlan()
plan.add(package_ahriman, BuildPlanReason.AURUpdate)
assert application.with_dependencies(plan, process_dependencies=True) is plan
assert plan.packages == [package_ahriman]
def test_with_dependencies_skip(application: Application, package_ahriman: Package, mocker: MockerFixture) -> None: def test_with_dependencies_skip(application: Application, package_ahriman: Package, mocker: MockerFixture) -> None:
@@ -157,8 +193,11 @@ def test_with_dependencies_skip(application: Application, package_ahriman: Packa
""" """
packages_mock = mocker.patch("ahriman.application.application.Application._known_packages") packages_mock = mocker.patch("ahriman.application.application.Application._known_packages")
assert application.with_dependencies([package_ahriman], process_dependencies=False) == [package_ahriman] plan = BuildPlan()
plan.add(package_ahriman, BuildPlanReason.AURUpdate)
assert application.with_dependencies(plan, process_dependencies=False) is plan
assert plan.packages == [package_ahriman]
packages_mock.assert_not_called() packages_mock.assert_not_called()
assert application.with_dependencies([], process_dependencies=True) == [] assert not application.with_dependencies(BuildPlan(), process_dependencies=True)
packages_mock.assert_not_called() packages_mock.assert_not_called()
@@ -7,6 +7,7 @@ from unittest.mock import call as MockCall
from ahriman.application.application.application_repository import ApplicationRepository from ahriman.application.application.application_repository import ApplicationRepository
from ahriman.core.exceptions import UnknownPackageError from ahriman.core.exceptions import UnknownPackageError
from ahriman.core.tree import Leaf, Tree from ahriman.core.tree import Leaf, Tree
from ahriman.models.build_plan import BuildPlan, BuildPlanReason
from ahriman.models.changes import Changes from ahriman.models.changes import Changes
from ahriman.models.package import Package from ahriman.models.package import Package
from ahriman.models.packagers import Packagers from ahriman.models.packagers import Packagers
@@ -270,6 +271,32 @@ def test_updates_all(application_repository: ApplicationRepository, package_ahri
updates_deps_mock.assert_called_once_with([]) updates_deps_mock.assert_called_once_with([])
def test_updates_returns_plan(application_repository: ApplicationRepository, package_ahriman: Package,
package_python_schedule: Package,
mocker: MockerFixture) -> None:
"""Update discovery records reasons in its build plan."""
mocker.patch("ahriman.core.repository.package_info.PackageInfo.packages_built", return_value=[Path("built")])
mocker.patch(
"ahriman.core.repository.package_info.PackageInfo.load_archives",
return_value=[package_python_schedule])
package_ahriman.packages[package_ahriman.base].make_depends = [package_python_schedule.base]
def collect(_filter: list[str], *, vcs: bool, plan: BuildPlan) -> list[Package]:
assert vcs
plan.add(package_ahriman, BuildPlanReason.AURUpdate)
return [package_ahriman]
mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.updates_aur", side_effect=collect)
plan = application_repository.updates([], aur=True, local=False, manual=False, vcs=True, check_files=False)
assert list(plan) == [package_ahriman, package_python_schedule]
assert plan.item(package_ahriman.base).reason == BuildPlanReason.AURUpdate
dependency = plan.item(package_python_schedule.base)
assert dependency.reason == BuildPlanReason.AlreadyBuilt
assert dependency.requester is None
def test_updates_disabled(application_repository: ApplicationRepository, mocker: MockerFixture) -> None: def test_updates_disabled(application_repository: ApplicationRepository, mocker: MockerFixture) -> None:
""" """
must get updates without anything must get updates without anything
@@ -9,6 +9,7 @@ from ahriman.application.handlers.update import Update
from ahriman.core.configuration import Configuration from ahriman.core.configuration import Configuration
from ahriman.core.repository import Repository from ahriman.core.repository import Repository
from ahriman.models.package import Package from ahriman.models.package import Package
from ahriman.models.build_plan import BuildPlan, BuildPlanReason
from ahriman.models.packagers import Packagers from ahriman.models.packagers import Packagers
from ahriman.models.result import Result from ahriman.models.result import Result
@@ -65,9 +66,11 @@ def test_perform_action(args: argparse.Namespace, application: Application, pack
result.add_updated(package_ahriman) result.add_updated(package_ahriman)
application_mock = mocker.patch("ahriman.application.application.Application.update", return_value=result) application_mock = mocker.patch("ahriman.application.application.Application.update", return_value=result)
check_mock = mocker.patch("ahriman.application.handlers.handler.Handler.check_status") check_mock = mocker.patch("ahriman.application.handlers.handler.Handler.check_status")
plan = BuildPlan()
plan.add(package_ahriman, BuildPlanReason.AURUpdate)
dependencies_mock = mocker.patch("ahriman.application.application.Application.with_dependencies", dependencies_mock = mocker.patch("ahriman.application.application.Application.with_dependencies",
return_value=[package_ahriman]) return_value=plan)
updates_mock = mocker.patch("ahriman.application.application.Application.updates", return_value=[package_ahriman]) updates_mock = mocker.patch("ahriman.application.application.Application.updates", return_value=plan)
changes_mock = mocker.patch("ahriman.application.application.Application.changes") changes_mock = mocker.patch("ahriman.application.application.Application.changes")
print_mock = mocker.patch("ahriman.application.application.Application.print_updates") print_mock = mocker.patch("ahriman.application.application.Application.print_updates")
@@ -78,9 +81,9 @@ def test_perform_action(args: argparse.Namespace, application: Application, pack
updates_mock.assert_called_once_with( updates_mock.assert_called_once_with(
args.package, aur=args.aur, local=args.local, manual=args.manual, vcs=args.vcs, check_files=args.check_files) args.package, aur=args.aur, local=args.local, manual=args.manual, vcs=args.vcs, check_files=args.check_files)
changes_mock.assert_called_once_with([package_ahriman]) changes_mock.assert_called_once_with([package_ahriman])
dependencies_mock.assert_called_once_with([package_ahriman], process_dependencies=args.dependencies) dependencies_mock.assert_called_once_with(plan, process_dependencies=args.dependencies)
check_mock.assert_called_once_with(False, True) check_mock.assert_called_once_with(False, True)
print_mock.assert_called_once_with([package_ahriman], log_fn=pytest.helpers.anyvar(int)) print_mock.assert_called_once_with(plan, log_fn=pytest.helpers.anyvar(int), bump_pkgrel=args.increment)
def test_perform_action_empty_exception(args: argparse.Namespace, application: Application, def test_perform_action_empty_exception(args: argparse.Namespace, application: Application,
@@ -91,7 +94,8 @@ def test_perform_action_empty_exception(args: argparse.Namespace, application: A
args = _default_args(args) args = _default_args(args)
args.exit_code = True args.exit_code = True
args.dry_run = True args.dry_run = True
mocker.patch("ahriman.application.application.Application.updates", return_value=[]) mocker.patch("ahriman.application.application.Application.updates", return_value=BuildPlan())
mocker.patch("ahriman.application.application.Application.print_updates")
check_mock = mocker.patch("ahriman.application.handlers.handler.Handler.check_status") check_mock = mocker.patch("ahriman.application.handlers.handler.Handler.check_status")
Update.perform_action(application, args) Update.perform_action(application, args)
@@ -106,8 +110,10 @@ def test_perform_action_update_empty_exception(args: argparse.Namespace, applica
args = _default_args(args) args = _default_args(args)
args.exit_code = True args.exit_code = True
mocker.patch("ahriman.application.application.Application.update", return_value=Result()) mocker.patch("ahriman.application.application.Application.update", return_value=Result())
mocker.patch("ahriman.application.application.Application.updates", return_value=[package_ahriman]) plan = BuildPlan()
mocker.patch("ahriman.application.application.Application.with_dependencies", return_value=[package_ahriman]) plan.add(package_ahriman, BuildPlanReason.AURUpdate)
mocker.patch("ahriman.application.application.Application.updates", return_value=plan)
mocker.patch("ahriman.application.application.Application.with_dependencies", return_value=plan)
mocker.patch("ahriman.application.application.Application.print_updates") mocker.patch("ahriman.application.application.Application.print_updates")
mocker.patch("ahriman.application.application.Application.changes") mocker.patch("ahriman.application.application.Application.changes")
check_mock = mocker.patch("ahriman.application.handlers.handler.Handler.check_status") check_mock = mocker.patch("ahriman.application.handlers.handler.Handler.check_status")
@@ -125,14 +131,17 @@ def test_perform_action_dry_run(args: argparse.Namespace, application: Applicati
args.dry_run = True args.dry_run = True
application_mock = mocker.patch("ahriman.application.application.Application.update") application_mock = mocker.patch("ahriman.application.application.Application.update")
check_mock = mocker.patch("ahriman.application.handlers.handler.Handler.check_status") check_mock = mocker.patch("ahriman.application.handlers.handler.Handler.check_status")
updates_mock = mocker.patch("ahriman.application.application.Application.updates", return_value=[package_ahriman]) plan = BuildPlan()
plan.add(package_ahriman, BuildPlanReason.AURUpdate)
updates_mock = mocker.patch("ahriman.application.application.Application.updates", return_value=plan)
changes_mock = mocker.patch("ahriman.application.application.Application.changes") changes_mock = mocker.patch("ahriman.application.application.Application.changes")
print_mock = mocker.patch("ahriman.application.application.Application.print_updates")
Update.perform_action(application, args) Update.perform_action(application, args)
updates_mock.assert_called_once_with( updates_mock.assert_called_once()
args.package, aur=args.aur, local=args.local, manual=args.manual, vcs=args.vcs, check_files=args.check_files)
application_mock.assert_not_called() application_mock.assert_not_called()
changes_mock.assert_called_once_with([package_ahriman]) changes_mock.assert_called_once_with([package_ahriman])
print_mock.assert_called_once_with(plan, log_fn=print, bump_pkgrel=args.increment)
check_mock.assert_called_once_with(False, [package_ahriman]) check_mock.assert_called_once_with(False, [package_ahriman])
@@ -145,7 +154,8 @@ def test_perform_action_no_changes(args: argparse.Namespace, application: Applic
args.changes = False args.changes = False
mocker.patch("ahriman.application.application.Application.update") mocker.patch("ahriman.application.application.Application.update")
mocker.patch("ahriman.application.handlers.handler.Handler.check_status") mocker.patch("ahriman.application.handlers.handler.Handler.check_status")
mocker.patch("ahriman.application.application.Application.updates") mocker.patch("ahriman.application.application.Application.updates", return_value=BuildPlan())
mocker.patch("ahriman.application.application.Application.print_updates")
changes_mock = mocker.patch("ahriman.application.application.Application.changes") changes_mock = mocker.patch("ahriman.application.application.Application.changes")
Update.perform_action(application, args) Update.perform_action(application, args)
@@ -0,0 +1,40 @@
from ahriman.core.formatters import BuildPlanPrinter
from ahriman.models.build_plan import BuildPlan, BuildPlanReason
from ahriman.models.package import Package
def test_print_plan(package_ahriman: Package) -> None:
"""
print package version and selection reason
"""
plan = BuildPlan()
plan.add(package_ahriman, BuildPlanReason.AURUpdate)
output: list[str] = []
BuildPlanPrinter(plan, {package_ahriman.base: package_ahriman.version})(
verbose=True, log_fn=output.append)
assert output == [
f"{package_ahriman.base}: {package_ahriman.version} -> {package_ahriman.version}",
"\tReason: AUR update",
]
def test_print_empty_plan() -> None:
"""The plan printer explains an empty preview."""
output: list[str] = []
BuildPlanPrinter(BuildPlan(), {})(verbose=True, log_fn=output.append)
assert output == ["No packages selected"]
def test_print_plan_concise(package_ahriman: Package) -> None:
"""The concise printer mode omits the reason while retaining package versions."""
plan = BuildPlan()
plan.add(package_ahriman, BuildPlanReason.AURUpdate)
output: list[str] = []
BuildPlanPrinter(plan, {})(verbose=False, log_fn=output.append)
assert output == [f"{package_ahriman.base}: N/A -> {package_ahriman.version}"]
@@ -34,6 +34,15 @@ def test_properties_keep_pkgrel(update_printer: UpdatePrinter) -> None:
] ]
def test_properties_no_increment(update_printer: UpdatePrinter) -> None:
"""The preview honors a disabled release increment."""
update_printer.local_version = update_printer.package.version
update_printer.bump_pkgrel = False
assert update_printer.properties() == [
Property(update_printer.local_version, update_printer.package.version, is_required=True),
]
def test_title(update_printer: UpdatePrinter) -> None: def test_title(update_printer: UpdatePrinter) -> None:
""" """
must return non-empty title must return non-empty title
@@ -6,6 +6,7 @@ from typing import Any
from ahriman.core.exceptions import UnknownPackageError from ahriman.core.exceptions import UnknownPackageError
from ahriman.core.repository.update_handler import UpdateHandler from ahriman.core.repository.update_handler import UpdateHandler
from ahriman.models.build_plan import BuildPlan, BuildPlanReason
from ahriman.models.build_status import BuildStatus, BuildStatusEnum from ahriman.models.build_status import BuildStatus, BuildStatusEnum
from ahriman.models.dependencies import Dependencies from ahriman.models.dependencies import Dependencies
from ahriman.models.event import EventType from ahriman.models.event import EventType
@@ -117,8 +118,10 @@ def test_updates_aur_filter(update_handler: UpdateHandler, package_ahriman: Pack
return_value=[package_ahriman]) return_value=[package_ahriman])
mocker.patch("ahriman.core.build_tools.package_version.PackageVersion.is_outdated", return_value=True) mocker.patch("ahriman.core.build_tools.package_version.PackageVersion.is_outdated", return_value=True)
package_load_mock = mocker.patch("ahriman.models.package.Package.from_aur", return_value=package_ahriman) package_load_mock = mocker.patch("ahriman.models.package.Package.from_aur", return_value=package_ahriman)
plan = BuildPlan()
assert update_handler.updates_aur([package_ahriman.base], vcs=True) == [package_ahriman] assert update_handler.updates_aur([package_ahriman.base], vcs=True, plan=plan) == [package_ahriman]
assert plan.item(package_ahriman.base).reason == BuildPlanReason.AURUpdate
packages_mock.assert_called_once_with([package_ahriman.base]) packages_mock.assert_called_once_with([package_ahriman.base])
package_load_mock.assert_called_once_with(package_ahriman.base, None) package_load_mock.assert_called_once_with(package_ahriman.base, None)
@@ -192,6 +195,7 @@ def test_updates_dependencies(update_handler: UpdateHandler, package_ahriman: Pa
return_value=[package_ahriman, package_python_schedule]) return_value=[package_ahriman, package_python_schedule])
status_client_mock = mocker.patch("ahriman.core.status.Client.set_pending") status_client_mock = mocker.patch("ahriman.core.status.Client.set_pending")
event_mock = mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.event") event_mock = mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.event")
plan = BuildPlan()
dependencies = { dependencies = {
package_ahriman.base: Dependencies({"usr/lib/python3.11/site-packages": ["python"]}), package_ahriman.base: Dependencies({"usr/lib/python3.11/site-packages": ["python"]}),
package_python_schedule.base: Dependencies({"usr/lib/python3.12/site-packages": ["python"]}), package_python_schedule.base: Dependencies({"usr/lib/python3.12/site-packages": ["python"]}),
@@ -201,7 +205,8 @@ def test_updates_dependencies(update_handler: UpdateHandler, package_ahriman: Pa
mocker.patch("ahriman.core.alpm.pacman.Pacman.files", mocker.patch("ahriman.core.alpm.pacman.Pacman.files",
return_value={"python": {"usr/lib/python3.12/site-packages"}}) return_value={"python": {"usr/lib/python3.12/site-packages"}})
assert update_handler.updates_dependencies(["filter"]) == [package_ahriman] assert update_handler.updates_dependencies(["filter"], plan=plan) == [package_ahriman]
assert plan.item(package_ahriman.base).reason == BuildPlanReason.BrokenImplicitDependency
packages_mock.assert_called_once_with(["filter"]) packages_mock.assert_called_once_with(["filter"])
status_client_mock.assert_called_once_with(package_ahriman.base) status_client_mock.assert_called_once_with(package_ahriman.base)
event_mock.assert_called_once_with(package_ahriman.base, EventType.PackageOutdated, event_mock.assert_called_once_with(package_ahriman.base, EventType.PackageOutdated,
@@ -263,8 +268,10 @@ def test_updates_local(update_handler: UpdateHandler, package_ahriman: Package,
event_mock = mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.event") event_mock = mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.event")
package_is_outdated_mock = mocker.patch("ahriman.core.build_tools.package_version.PackageVersion.is_outdated", package_is_outdated_mock = mocker.patch("ahriman.core.build_tools.package_version.PackageVersion.is_outdated",
return_value=True) return_value=True)
plan = BuildPlan()
assert update_handler.updates_local(vcs=True) == [package_ahriman] assert update_handler.updates_local(vcs=True, plan=plan) == [package_ahriman]
assert plan.item(package_ahriman.base).reason == BuildPlanReason.LocalSourceUpdate
fetch_mock.assert_called_once_with(Path(package_ahriman.base), pytest.helpers.anyvar(int)) fetch_mock.assert_called_once_with(Path(package_ahriman.base), pytest.helpers.anyvar(int))
package_load_mock.assert_called_once_with(Path(package_ahriman.base), "x86_64", None) package_load_mock.assert_called_once_with(Path(package_ahriman.base), "x86_64", None)
status_client_mock.assert_called_once_with(package_ahriman.base) status_client_mock.assert_called_once_with(package_ahriman.base)
@@ -368,8 +375,10 @@ def test_updates_manual_preserves_queue(update_handler: UpdateHandler, package_a
""" """
update_handler.database.build_queue_insert(package_ahriman) update_handler.database.build_queue_insert(package_ahriman)
mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.packages", return_value=[package_ahriman]) mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.packages", return_value=[package_ahriman])
plan = BuildPlan()
assert update_handler.updates_manual() == [package_ahriman] assert update_handler.updates_manual(plan=plan) == [package_ahriman]
assert plan.item(package_ahriman.base).reason == BuildPlanReason.QueuedRequest
assert update_handler.database.build_queue_get() == [package_ahriman] assert update_handler.database.build_queue_get() == [package_ahriman]
@@ -0,0 +1,28 @@
from ahriman.models.build_plan import BuildPlan, BuildPlanReason
from ahriman.models.package import Package
def test_add_and_merge_plan_items(package_ahriman: Package, package_python_schedule: Package) -> None:
"""A plan keeps one current package and the last reason per base."""
plan = BuildPlan()
item = plan.add(package_ahriman, BuildPlanReason.AURUpdate)
plan.add(package_ahriman, BuildPlanReason.AURUpdate)
item = plan.add(package_ahriman, BuildPlanReason.QueuedRequest)
plan.add(package_python_schedule, BuildPlanReason.LocalSourceUpdate)
assert item.reason == BuildPlanReason.QueuedRequest
assert plan.packages == sorted([package_ahriman, package_python_schedule], key=lambda package: package.base)
assert plan.item(package_ahriman.base) is item
def test_add_with_requester(package_python_schedule: Package) -> None:
"""A plan records which selected package requires a dependency."""
plan = BuildPlan()
plan.add(package_python_schedule, BuildPlanReason.RequiredBy, requester="ahriman")
plan.add(package_python_schedule, BuildPlanReason.RequiredBy, requester="python-ahriman")
item = plan.item(package_python_schedule.base)
assert item.reason == BuildPlanReason.RequiredBy
assert item.requester == "python-ahriman"
+8
View File
@@ -4,6 +4,14 @@ ahriman.core.formatters package
Submodules Submodules
---------- ----------
ahriman.core.formatters.build\_plan\_printer module
----------------------------------------------------
.. automodule:: ahriman.core.formatters.build_plan_printer
:members:
:no-undoc-members:
:show-inheritance:
ahriman.core.formatters.aur\_printer module ahriman.core.formatters.aur\_printer module
------------------------------------------- -------------------------------------------
+8
View File
@@ -28,6 +28,14 @@ ahriman.models.auth\_settings module
:no-undoc-members: :no-undoc-members:
:show-inheritance: :show-inheritance:
ahriman.models.build\_plan module
---------------------------------
.. automodule:: ahriman.models.build_plan
:members:
:no-undoc-members:
:show-inheritance:
ahriman.models.build\_status module ahriman.models.build\_status module
----------------------------------- -----------------------------------
+2
View File
@@ -274,6 +274,8 @@ In this scenario, the update process must be separated into several stages. Firs
sudo -u ahriman ahriman repo-check sudo -u ahriman ahriman repo-check
The command prints selected packages in dependency steps, with the old and proposed versions and the reason each package was selected. ``repo-update --dry-run`` uses the same preview. Proposed ``pkgrel`` values follow the ``--increment`` option. The preview describes current metadata; it does not freeze sources or guarantee later build inputs.
During the check process, the service will generate changes from the last known commit and will send it to remote service. In order to verify source files changes, the web interface or special subcommand can be used: During the check process, the service will generate changes from the last known commit and will send it to remote service. In order to verify source files changes, the web interface or special subcommand can be used:
.. code-block:: shell .. code-block:: shell