.ci/mypy.sh

@@ -4,10 +4,11 @@
 
 if [ "$(id -u)" = 0 ]; then
 	set -x
-	apk -q add py3-argcomplete py3-mypy
+	apk -q add py3-argcomplete py3-pip
 	exec su "${TESTUSER:-build}" -c "sh -e $0"
 fi
 
 set -x
 
-mypy --color-output pmbootstrap.py
+pip install --break-system-packages --no-warn-script-location mypy
+python -m mypy --color-output pmbootstrap.py

pmb/aportgen/__init__.py

 # Copyright 2023 Oliver Smith
 # SPDX-License-Identifier: GPL-3.0-or-later
 import os
+from pmb.core.arch import Arch
 from pmb.core.context import get_context
 from pmb.core.pkgrepo import pkgrepo_default_path
 from pmb.helpers import logging
@@ -16,13 +17,17 @@ from pmb.types import PmbArgs
 import pmb.helpers.cli
 
 
-def get_cross_package_arches(pkgname):
+def get_cross_package_arches(pkgname: str) -> str:
     """
     Get the arches for which we want to build cross packages.
 
     :param pkgname: package name, e.g. "gcc-aarch64", "gcc-x86_64"
 
-    :returns: string of architecture(s) (space separated)
+    :returns: string of architecture(s) (space separated). It doesn't
+    necessarily make sense to use Arch here given that this value gets
+    used to write APKBUILD files, where the ``arch`` field can have values
+    that aren't necessarily valid arches like "!armhf", "noarch", or
+    "x86 x86_64".
 
     """
     if pkgname.endswith("-x86_64"):
@@ -59,7 +64,7 @@ def properties(pkgname):
     raise ValueError("No generator available for " + pkgname + "!")
 
 
-def generate(pkgname: str, fork_alpine: bool):
+def generate(pkgname: str, fork_alpine: bool, fork_alpine_retain_branch: bool = False) -> None:
     if fork_alpine:
         prefix, folder, options = (pkgname, "temp", {"confirm_overwrite": True})
     else:
@@ -78,7 +83,9 @@ def generate(pkgname: str, fork_alpine: bool):
     if os.path.exists(aportgen):
         pmb.helpers.run.user(["rm", "-r", aportgen])
     if fork_alpine:
-        upstream = pmb.aportgen.core.get_upstream_aport(pkgname)
+        upstream = pmb.aportgen.core.get_upstream_aport(
+            pkgname, retain_branch=fork_alpine_retain_branch
+        )
         pmb.helpers.run.user(["cp", "-r", upstream, aportgen])
         pmb.aportgen.core.rewrite(
             pkgname, replace_simple={"# Contributor:*": None, "# Maintainer:*": None}

pmb/aportgen/busybox_static.py

@@ -8,16 +8,21 @@ import pmb.chroot.apk_static
 import pmb.helpers.run
 import pmb.parse.apkindex
 from pmb.core import Chroot
+from pmb.core.arch import Arch
 from pmb.core.context import get_context
 
 
 def generate(pkgname: str) -> None:
-    arch = pkgname.split("-")[2]
+    arch = Arch.from_str(pkgname.split("-")[2])
     context = get_context()
 
     # Parse version from APKINDEX
     package_data = pmb.parse.apkindex.package("busybox")
-    version = package_data["version"]
+
+    if package_data is None:
+        raise RuntimeError("Couldn't find APKINDEX for busybox!")
+
+    version = package_data.version
     pkgver = version.split("-r")[0]
     pkgrel = version.split("-r")[1]
 

pmb/aportgen/core.py

@@ -2,14 +2,15 @@
 # SPDX-License-Identifier: GPL-3.0-or-later
 import fnmatch
 from pmb.helpers import logging
+from pathlib import Path
 import re
 import pmb.helpers.git
 import pmb.helpers.run
-import pmb.helpers.args
+from pmb.core.arch import Arch
 from pmb.core.context import get_context
 
 
-def indent_size(line):
+def indent_size(line: str) -> int:
     """
     Number of spaces at the beginning of a string.
     """
@@ -19,7 +20,7 @@ def indent_size(line):
     return 0
 
 
-def format_function(name, body, remove_indent=4):
+def format_function(name: str, body: str, remove_indent: int = 4) -> str:
     """
     Format the body of a shell function passed to rewrite() below, so it fits
     the format of the original APKBUILD.
@@ -50,15 +51,15 @@ def format_function(name, body, remove_indent=4):
 
 
 def rewrite(
-    pkgname,
-    path_original="",
-    fields={},
-    replace_pkgname=None,
-    replace_functions={},
-    replace_simple={},
-    below_header="",
-    remove_indent=4,
-):
+    pkgname: str,
+    path_original: Path | str | None = None,
+    fields: dict[str, str] = {},
+    replace_pkgname: str | None = None,
+    replace_functions: dict[str, str | None] = {},
+    replace_simple: dict = {},  # Can't type this dictionary properly without fixing type errors
+    below_header: str = "",
+    remove_indent: int = 4,
+) -> None:
     """
     Append a header to $WORK/aportgen/APKBUILD, delete maintainer/contributor
     lines (so they won't be bugged with issues regarding our generated aports),
@@ -160,7 +161,7 @@ def rewrite(
         handle.truncate()
 
 
-def get_upstream_aport(pkgname: str, arch=None):
+def get_upstream_aport(pkgname: str, arch: Arch | None = None, retain_branch: bool = False):
     """
     Perform a git checkout of Alpine's aports and get the path to the aport.
 
@@ -173,9 +174,7 @@ def get_upstream_aport(pkgname: str, arch=None):
     pmb.helpers.git.clone("aports_upstream")
     aports_upstream_path = get_context().config.work / "cache_git/aports_upstream"
 
-    args = pmb.helpers.args.please_i_really_need_args()
-
-    if getattr(args, "fork_alpine_retain_branch", False):
+    if retain_branch:
         logging.info("Not changing aports branch as --fork-alpine-retain-branch was " "used.")
     else:
         # Checkout branch
@@ -211,14 +210,17 @@ def get_upstream_aport(pkgname: str, arch=None):
     index_path = pmb.helpers.repo.alpine_apkindex_path(repo, arch)
     package = pmb.parse.apkindex.package(pkgname, indexes=[index_path])
 
+    if package is None:
+        raise RuntimeError(f"Couldn't find {pkgname} in APKINDEX!")
+
     # Compare version (return when equal)
-    compare = pmb.parse.version.compare(apkbuild_version, package["version"])
+    compare = pmb.parse.version.compare(apkbuild_version, package.version)
 
     # APKBUILD > binary: this is fine
     if compare == 1:
         logging.info(
             f"NOTE: {pkgname} {arch} binary package has a lower"
-            f" version {package['version']} than the APKBUILD"
+            f" version {package.version} than the APKBUILD"
             f" {apkbuild_version}"
         )
         return aport_path
@@ -230,7 +232,7 @@ def get_upstream_aport(pkgname: str, arch=None):
             " local checkout of Alpine's aports ("
             + apkbuild_version
             + ") compared to Alpine's binary package ("
-            + package["version"]
+            + package.version
             + ")!"
         )
         logging.info("NOTE: You can update your local checkout with: 'pmbootstrap pull'")

pmb/aportgen/gcc.py

 # Copyright 2023 Oliver Smith
 # SPDX-License-Identifier: GPL-3.0-or-later
 import pmb.aportgen.core
+from pmb.core.arch import Arch
 from pmb.core.context import get_context
 from pmb.core.pkgrepo import pkgrepo_default_path
 import pmb.helpers.git
@@ -10,7 +11,7 @@ import pmb.helpers.run
 def generate(pkgname: str):
     # Copy original aport
     prefix = pkgname.split("-")[0]
-    arch = pkgname.split("-")[1]
+    arch = Arch.from_str(pkgname.split("-")[1])
     context = get_context()
     if prefix == "gcc":
         upstream = pmb.aportgen.core.get_upstream_aport("gcc", arch)
@@ -51,7 +52,7 @@ def generate(pkgname: str):
 
     below_header = (
         "CTARGET_ARCH="
-        + arch
+        + str(arch)
         + """
         CTARGET="$(arch_to_hostspec ${CTARGET_ARCH})"
         LANG_D=false

pmb/aportgen/grub_efi.py

@@ -12,12 +12,14 @@ from pmb.core import Chroot
 from pmb.core.context import get_context
 
 
-def generate(pkgname):
-    arch = "x86"
+def generate(pkgname: str) -> None:
+    arch = Arch.x86
     if pkgname != "grub-efi-x86":
         raise RuntimeError("only grub-efi-x86 is available")
     package_data = pmb.parse.apkindex.package("grub")
-    version = package_data["version"]
+    if package_data is None:
+        raise RuntimeError("Couldn't find package grub!")
+    version = package_data.version
     pkgver = version.split("-r")[0]
     pkgrel = version.split("-r")[1]
 

pmb/aportgen/musl.py

@@ -8,15 +8,18 @@ import pmb.chroot.apk_static
 import pmb.helpers.run
 import pmb.parse.apkindex
 from pmb.core import Chroot
+from pmb.core.arch import Arch
 from pmb.core.context import get_context
 
 
-def generate(pkgname):
-    arch = pkgname.split("-")[1]
+def generate(pkgname: str) -> None:
+    arch = Arch.from_str(pkgname.split("-")[1])
 
     # Parse musl version from APKINDEX
     package_data = pmb.parse.apkindex.package("musl")
-    version = package_data["version"]
+    if package_data is None:
+        raise RuntimeError("Couldn't find package musl!")
+    version = package_data.version
     pkgver = version.split("-r")[0]
     pkgrel = version.split("-r")[1]
 

pmb/build/_package.py

@@ -51,7 +51,7 @@ def check_build_for_arch(pkgname: str, arch: Arch):
         pmaport_version = pmaport["pkgver"] + "-r" + pmaport["pkgrel"]
         logging.debug(
             pkgname + ": found pmaport (" + pmaport_version + ") and"
-            " binary package (" + binary["version"] + ", from"
+            " binary package (" + binary.version + ", from"
             " postmarketOS or Alpine), but pmaport can't be built"
             f" for {arch} -> using binary package"
         )
@@ -274,7 +274,7 @@ def prioritise_build_queue(disarray: list[BuildQueueItem]) -> list[BuildQueueIte
                 )
                 if not dep_data:
                     raise NonBugError(f"{item['name']}: dependency not found: {dep}")
-                dep = dep_data["pkgname"]
+                dep = dep_data.pkgname
 
                 if dep in all_pkgnames:
                     unmet_deps.setdefault(item["name"], []).append(dep)
@@ -483,11 +483,11 @@ def packages(
         # building with --src with an outdated pmaports checkout.
         if (
             index_data
-            and pmb.parse.version.compare(index_data["version"], f"{pkgver}-r{apkbuild['pkgrel']}")
+            and pmb.parse.version.compare(index_data.version, f"{pkgver}-r{apkbuild['pkgrel']}")
             == 1
         ):
             raise NonBugError(
-                f"A binary package for {name} has a newer version ({index_data['version']})"
+                f"A binary package for {name} has a newer version ({index_data.version})"
                 f" than the source ({pkgver}-{apkbuild['pkgrel']}). Please ensure your pmaports branch is up"
                 " to date and that you don't have a newer version of the package in your local"
                 f" binary repo ({context.config.work / 'packages' / channel / pkg_arch})."
@@ -579,6 +579,7 @@ def packages(
         )
 
     cross = None
+    prev_cross = None
 
     total_pkgs = len(build_queue)
     count = 0
@@ -606,11 +607,11 @@ def packages(
         if src:
             pkg_depends.append("rsync")
 
-        # We only need to init cross compiler stuff once
-        if not cross:
-            cross = pmb.build.autodetect.crosscompile(pkg["apkbuild"], pkg_arch)
-            if cross:
-                pmb.build.init_compiler(context, pkg_depends, cross, pkg_arch)
+        # (re)-initialize the cross compiler stuff when cross method changes
+        prev_cross = cross
+        cross = pmb.build.autodetect.crosscompile(pkg["apkbuild"], pkg_arch)
+        if cross != prev_cross:
+            pmb.build.init_compiler(context, pkg_depends, cross, pkg_arch)
             if cross == "crossdirect":
                 pmb.chroot.mount_native_into_foreign(chroot)
 

pmb/build/other.py

@@ -107,7 +107,7 @@ def get_status(arch, apkbuild) -> BuildStatus:
         return BuildStatus.CANT_BUILD
 
     # a) Binary repo has a newer version
-    version_binary = index_data["version"]
+    version_binary = index_data.version
     if pmb.parse.version.compare(version_binary, version_pmaports) == 1:
         logging.warning(
             f"WARNING: about to install {package} {version_binary}"

pmb/chroot/apk.py

 # Copyright 2023 Oliver Smith
 # SPDX-License-Identifier: GPL-3.0-or-later
+
+from __future__ import annotations
+
 import os
 from pathlib import Path
 import traceback
@@ -98,7 +101,7 @@ def check_min_version(chroot: Chroot = Chroot.native()):
         )
 
     # Compare
-    version_installed = installed_pkgs["apk-tools"]["version"]
+    version_installed = installed_pkgs["apk-tools"].version
     pmb.helpers.apk.check_outdated(
         version_installed,
         "Delete your http cache and zap all chroots, then try again:" " 'pmbootstrap zap -hc'",
@@ -126,7 +129,7 @@ def packages_split_to_add_del(packages):
     return (to_add, to_del)
 
 
-def packages_get_locally_built_apks(packages, arch: Arch) -> list[Path]:
+def packages_get_locally_built_apks(package_list: list[str], arch: Arch) -> list[Path]:
     """
     Iterate over packages and if existing, get paths to locally built packages.
     This is used to force apk to upgrade packages to newer local versions, even
@@ -141,7 +144,7 @@ def packages_get_locally_built_apks(packages, arch: Arch) -> list[Path]:
     channels: list[str] = pmb.config.pmaports.all_channels()
     local: list[Path] = []
 
-    packages = set(packages)
+    packages = set(package_list)
 
     walked: set[str] = set()
     while len(packages):
@@ -150,7 +153,7 @@ def packages_get_locally_built_apks(packages, arch: Arch) -> list[Path]:
         if not data_repo:
             continue
 
-        apk_file = f"{data_repo['pkgname']}-{data_repo['version']}.apk"
+        apk_file = f"{data_repo.pkgname}-{data_repo.version}.apk"
         # FIXME: we should know what channel we expect this package to be in
         # this will have weird behaviour if you build gnome-shell for edge and
         # then checkout out the systemd branch... But there isn't
@@ -163,12 +166,13 @@ def packages_get_locally_built_apks(packages, arch: Arch) -> list[Path]:
                 break
 
         # Record all the packages we have visited so far
-        walked |= set([data_repo["pkgname"], package])
-        # Add all dependencies to the list of packages to check, excluding
-        # meta-deps like cmd:* and so:* as well as conflicts (!).
-        packages |= (
-            set(filter(lambda x: ":" not in x and "!" not in x, data_repo["depends"])) - walked
-        )
+        walked |= set([data_repo.pkgname, package])
+        if data_repo.depends:
+            # Add all dependencies to the list of packages to check, excluding
+            # meta-deps like cmd:* and so:* as well as conflicts (!).
+            packages |= (
+                set(filter(lambda x: ":" not in x and "!" not in x, data_repo.depends)) - walked
+            )
 
     return local
 
@@ -283,21 +287,13 @@ def install(packages, chroot: Chroot, build=True, quiet: bool = False):
     install_run_apk(to_add, to_add_local, to_del, chroot)
 
 
-def installed(suffix: Chroot = Chroot.native()):
+def installed(suffix: Chroot = Chroot.native()) -> dict[str, pmb.parse.apkindex.ApkindexBlock]:
     """
     Read the list of installed packages (which has almost the same format, as
     an APKINDEX, but with more keys).
 
     :returns: a dictionary with the following structure:
-              { "postmarketos-mkinitfs":
-              {
-              "pkgname": "postmarketos-mkinitfs"
-              "version": "0.0.4-r10",
-              "depends": ["busybox-extras", "lddtree", ...],
-              "provides": ["mkinitfs=0.0.1"]
-              }, ...
-
-              }
+              { "postmarketos-mkinitfs": ApkindexBlock }
 
     """
     path = suffix / "lib/apk/db/installed"

pmb/chroot/apk_static.py

@@ -157,14 +157,18 @@ def download(file):
     return pmb.helpers.http.download(f"{base_url}/{file}", file)
 
 
-def init():
+def init() -> None:
     """
     Download, verify, extract $WORK/apk.static.
     """
     # Get and parse the APKINDEX
     apkindex = pmb.helpers.repo.alpine_apkindex_path("main")
     index_data = pmb.parse.apkindex.package("apk-tools-static", indexes=[apkindex])
-    version = index_data["version"]
+
+    if index_data is None:
+        raise RuntimeError("Could not find apk-tools-static in APKINDEX!")
+
+    version = index_data.version
 
     # Verify the apk-tools-static version
     pmb.helpers.apk.check_outdated(version, "Run 'pmbootstrap update', then try again.")

pmb/chroot/test_apk.py

+from pathlib import Path
+
 import pytest
 
 from pmb.core.arch import Arch
 from pmb.core.context import get_context
+from pmb.parse.apkindex import ApkindexBlock
 
 from .apk import packages_get_locally_built_apks
 import pmb.config.pmaports
 
 
 @pytest.fixture
-def apk_mocks(monkeypatch):
+def apk_mocks(monkeypatch) -> dict | None:
     def _pmaports_config(_aports=None):
         return {
             "channel": "edge",
@@ -16,48 +19,67 @@ def apk_mocks(monkeypatch):
 
     monkeypatch.setattr(pmb.config.pmaports, "read_config", _pmaports_config)
 
-    def _apkindex_package(_package, _arch, _must_exist=False, indexes=None):
+    def _apkindex_package(
+        _package: str, _arch: Arch, _must_exist: bool = False, indexes=None
+    ) -> ApkindexBlock:
         if _package == "package1":
-            return {
-                "pkgname": _package,
-                "version": "5.5-r0",
-                "arch": str(_arch),
-                "depends": ["package2"],
-            }
+            return ApkindexBlock(
+                arch=_arch,
+                depends=["package2"],
+                origin=None,
+                pkgname=_package,
+                provides=[],
+                provider_priority=None,
+                timestamp=None,
+                version="5.5-r0",
+            )
         if _package == "package2":
-            return {
-                "pkgname": _package,
-                "version": "5.5-r0",
-                "arch": str(_arch),
-                "depends": [],
-            }
+            return ApkindexBlock(
+                arch=_arch,
+                depends=[],
+                origin=None,
+                pkgname=_package,
+                provides=[],
+                provider_priority=None,
+                timestamp=None,
+                version="5.5-r0",
+            )
         if _package == "package3":
-            return {
-                "pkgname": _package,
-                "version": "5.5-r0",
-                "arch": str(_arch),
-                "depends": ["package1", "package4"],
-            }
+            return ApkindexBlock(
+                arch=_arch,
+                depends=["package1", "package4"],
+                origin=None,
+                pkgname=_package,
+                provides=[],
+                provider_priority=None,
+                timestamp=None,
+                version="5.5-r0",
+            )
         # Test recursive dependency
         if _package == "package4":
-            return {
-                "pkgname": _package,
-                "version": "5.5-r0",
-                "arch": str(_arch),
-                "depends": ["package3"],
-            }
+            return ApkindexBlock(
+                arch=_arch,
+                depends=["package3"],
+                origin=None,
+                pkgname=_package,
+                provides=[],
+                provider_priority=None,
+                timestamp=None,
+                version="5.5-r0",
+            )
 
     monkeypatch.setattr(pmb.parse.apkindex, "package", _apkindex_package)
+    return None
 
 
-def create_apk(pkgname, arch):
+def create_apk(pkgname: str, arch: Arch) -> Path:
     apk_file = get_context().config.work / "packages" / "edge" / arch / f"{pkgname}-5.5-r0.apk"
     apk_file.parent.mkdir(parents=True, exist_ok=True)
     apk_file.touch()
     return apk_file
 
 
-def test_get_local_apks(pmb_args, apk_mocks):
+def test_get_local_apks(pmb_args, apk_mocks) -> None:
     """Ensure packages_get_locally_built_apks() returns paths for local apks"""
 
     pkgname = "package1"

pmb/chroot/zap.py

@@ -116,7 +116,7 @@ def zap(
         logging.info("Dry run: nothing has been deleted")
 
 
-def zap_pkgs_local_mismatch(confirm=True, dry=False):
+def zap_pkgs_local_mismatch(confirm: bool = True, dry: bool = False) -> None:
     channel = pmb.config.pmaports.read_config()["channel"]
     if not os.path.exists(f"{get_context().config.work}/packages/{channel}"):
         return
@@ -135,10 +135,10 @@ def zap_pkgs_local_mismatch(confirm=True, dry=False):
         # Delete packages without same version in aports
         blocks = pmb.parse.apkindex.parse_blocks(apkindex_path)
         for block in blocks:
-            pkgname = block["pkgname"]
-            origin = block["origin"]
-            version = block["version"]
-            arch = block["arch"]
+            pkgname = block.pkgname
+            origin = block.origin
+            version = block.version
+            arch = block.arch
 
             # Apk path
             apk_path_short = f"{arch}/{pkgname}-{version}.apk"
@@ -147,6 +147,9 @@ def zap_pkgs_local_mismatch(confirm=True, dry=False):
                 logging.info("WARNING: Package mentioned in index not" f" found: {apk_path_short}")
                 continue
 
+            if origin is None:
+                raise RuntimeError("Can't handle virtual packages")
+
             # Aport path
             aport_path = pmb.helpers.pmaports.find_optional(origin)
             if not aport_path:

pmb/commands/__init__.py

@@ -65,7 +65,7 @@ def run_command(args: PmbArgs):
     command: Command
     match args.action:
         case "aportgen":
-            command = Aportgen(args.packages, args.fork_alpine)
+            command = Aportgen(args.packages, args.fork_alpine, args.fork_alpine_retain_branch)
         case "log":
             command = Log(args.clear_log, args.lines)
         case "index":

pmb/commands/aportgen.py

@@ -8,11 +8,14 @@ from pmb.helpers import logging
 
 
 class Aportgen(commands.Command):
-    def __init__(self, package_list: list[str], fork_alpine: bool) -> None:
+    def __init__(
+        self, package_list: list[str], fork_alpine: bool, fork_alpine_retain_branch: bool
+    ) -> None:
         self.package_list = package_list
         self.fork_alpine = fork_alpine
+        self.fork_alpine_retain_branch = fork_alpine_retain_branch
 
     def run(self) -> None:
         for package in self.package_list:
             logging.info(f"Generate aport: {package}")
-            pmb.aportgen.generate(package, self.fork_alpine)
+            pmb.aportgen.generate(package, self.fork_alpine, self.fork_alpine_retain_branch)

pmb/config/__init__.py

@@ -283,17 +283,12 @@ apkbuild_attributes = {
 }
 
 # Reference: https://postmarketos.org/apkbuild-options
+# In addition to these, pmbootstrap adds "pmb:kconfigcheck-community" etc.
+# dynamically based on kconfigcheck.toml in the currently checked out pmaports
+# branch
 apkbuild_custom_valid_options = [
     "!pmb:crossdirect",
     "!pmb:kconfigcheck",
-    "pmb:kconfigcheck-community",
-    "pmb:kconfigcheck-containers",
-    "pmb:kconfigcheck-iwd",
-    "pmb:kconfigcheck-netboot",
-    "pmb:kconfigcheck-nftables",
-    "pmb:kconfigcheck-uefi",
-    "pmb:kconfigcheck-waydroid",
-    "pmb:kconfigcheck-zram",
     "pmb:cross-native",
     "pmb:gpu-accel",
     "pmb:strict",

pmb/core/apkindex_block.py

+# Copyright 2024 Stefan Hansson
+# SPDX-License-Identifier: GPL-3.0-or-later
+from dataclasses import dataclass
+
+from pmb.core.arch import Arch
+
+
+@dataclass
+class ApkindexBlock:
+    """
+    "depends" is not set for packages without any dependencies, e.g. ``musl``.
+
+    "timestamp" and "origin" are not set for virtual packages (#1273).
+    We use that information to skip these virtual packages in parse().
+    """
+
+    arch: Arch
+    depends: list[str] | None
+    origin: str | None
+    pkgname: str
+    provides: list[str]
+    provider_priority: int | None
+    timestamp: str | None
+    version: str

pmb/core/dps.py

+# Copyright 2024 Aster Boese
+# SPDX-License-Identifier: GPL-3.0-or-later
+# Based on https://uapi-group.org/specifications/specs/discoverable_partitions_specification
+
+boot = {
+    "esp": ["ESP", "c12a7328-f81f-11d2-ba4b-00a0c93ec93b"],
+    "xbootldr": ["XBOOTLDR", "bc13c2ff-59e6-4262-a352-b275fd6f7172"],
+}
+
+directory = {
+    "swap": ["SD_GPT_SWAP", "0657fd6d-a4ab-43c4-84e5-0933c84b4f4f"],
+    "home": ["SD_GPT_HOME", "933ac7e1-2eb4-4f13-b844-0e14e2aef915"],
+    "srv": ["SD_GPT_SRV", "3b8f8425-20e0-4f3b-907f-1a25a76f98e8"],
+    "var": ["SD_GPT_VAR", "4d21b016-b534-45c2-a9fb-5c16e091fd2d"],
+    "tmp": ["SD_GPT_TMP", "7ec6f557-3bc5-4aca-b293-16ef5df639d1"],
+    "user_home": ["SD_GPT_USER_HOME", "773f91ef-66d4-49b5-bd83-d683bf40ad16"],
+    "generic": ["SD_GPT_LINUX_GENERIC", "0fc63daf-8483-4772-8e79-3d69d8477de4"],
+}
+
+root = {
+    "x86": ["SD_GPT_ROOT_X86", "44479540-f297-41b2-9af7-d131d5f0458a"],
+    "x86_64": ["SD_GPT_ROOT_X86_64", "4f68bce3-e8cd-4db1-96e7-fbcaf984b709"],
+    # The three non-x64 ARMs are lumped into ARM
+    "armhf": ["SD_GPT_ROOT_ARM", "69dad710-2ce4-4e3c-b16c-21a1d49abed3"],
+    "armv7": ["SD_GPT_ROOT_ARM", "69dad710-2ce4-4e3c-b16c-21a1d49abed3"],
+    "aarch64": ["SD_GPT_ROOT_ARM64", "b921b045-1df0-41c3-af44-4c6f280d3fae"],
+    "riscv64": ["SD_GPT_ROOT_RISCV64", "72ec70a6-cf74-40e6-bd49-4bda08e8f224"],
+    "s390x": ["SD_GPT_ROOT_S390X", "5eead9a9-fe09-4a1e-a1d7-520d00531306"],
+    "ppc64le": ["SD_GPT_ROOT_PPC64_LE", "c31c45e6-3f39-412e-80fb-4809c4980599"],
+    # The three non-x64 ARMs are lumped into ARM
+    "armel": ["SD_GPT_ROOT_ARM", "69dad710-2ce4-4e3c-b16c-21a1d49abed3"],
+    # Not supported by the spec
+    "loongarch32": ["SD_GPT_ROOT_LOONGARCH64", "77055800-792c-4f94-b39a-98c91b762bb6"],
+    # Not supported by the spec
+    "loongarchx32": ["SD_GPT_ROOT_LOONGARCH64", "77055800-792c-4f94-b39a-98c91b762bb6"],
+    "loongarch64": ["SD_GPT_ROOT_LOONGARCH64", "77055800-792c-4f94-b39a-98c91b762bb6"],
+    "mips": ["SD_GPT_ROOT_MIPS", "e9434544-6e2c-47cc-bae2-12d6deafb44c"],
+    "mips64": ["SD_GPT_ROOT_MIPS64", "d113af76-80ef-41b4-bdb6-0cff4d3d4a25"],
+    "mipsel": ["SD_GPT_ROOT_MIPSEL", "37c58c8a-d913-4156-a25f-48b1b64e07f0"],
+    "mips64el": ["SD_GPT_ROOT_MIPS64_LE", "700bda43-7a34-4507-b179-eeb93d7a7ca3"],
+    "ppc": ["SD_GPT_ROOT_PPC", "1de3f1ef-fa98-47b5-8dcd-4a860a654d78"],
+    "ppc64": ["SD_GPT_ROOT_PPC64", "912ade1d-a839-4913-8964-a10eee08fbd2"],
+    "riscv32": ["SD_GPT_ROOT_RISCV32", "60d5a7fe-8e7d-435c-b714-3dd8162144e1"],
+}
+
+usr = {
+    # See above for weirdly named partition types
+    "x86": ["SD_GPT_USR_X86", "75250d76-8cc6-458e-bd66-bd47cc81a812"],
+    "x86_64": ["SD_GPT_USR_X86_64", "8484680c-9521-48c6-9c11-b0720656f69e"],
+    "armhf": ["SD_GPT_USR_ARM", "7386cdf2-203c-47a9-a498-f2ecce45a2d6"],
+    "armv7": ["SD_GPT_USR_ARM", "7386cdf2-203c-47a9-a498-f2ecce45a2d6"],
+    "aarch64": ["SD_GPT_USR_ARM64", "df3300ce-d69f-4c92-978c-9bfb0f38d820"],
+    "riscv64": ["SD_GPT_USR_RISCV64", "b6ed5582-440b-4209-b8da-5ff7c419ea3d"],
+    "s390x": ["SD_GPT_USR_S390X", "b325bfbe-c7be-4ab8-8357-139e652d2f6b"],
+    "ppc64le": ["SD_GPT_USR_PPC64_LE", "ee2b9983-21e8-4153-86d9-b6901a54d1ce"],
+    "armel": ["SD_GPT_USR_ARM", "7386cdf2-203c-47a9-a498-f2ecce45a2d6"],
+    "loongarch32": ["SD_GPT_USR_LOONGARCH64", "e611c702-575c-4cbe-9a46-434fa0bf7e3f"],
+    "loongarchx32": ["SD_GPT_USR_LOONGARCH64", "e611c702-575c-4cbe-9a46-434fa0bf7e3f"],
+    "loongarch64": ["SD_GPT_USR_LOONGARCH64", "e611c702-575c-4cbe-9a46-434fa0bf7e3f"],
+    "mips": ["SD_GPT_USR_MIPS", "773b2abc-2a99-4398-8bf5-03baac40d02b"],
+    "mips64": ["SD_GPT_USR_MIPS64", "57e13958-7331-4365-8e6e-35eeee17c61b"],
+    "mipsel": ["SD_GPT_USR_MIPS_LE", "0f4868e9-9952-4706-979f-3ed3a473e947"],
+    "mips64el": ["SD_GPT_USR_MIPS64_LE", "c97c1f32-ba06-40b4-9f22-236061b08aa8"],
+    "ppc": ["SD_GPT_USR_PPC", "7d14fec5-cc71-415d-9d6c-06bf0b3c3eaf"],
+    "ppc64": ["SD_GPT_USR_PPC64", "2c9739e2-f068-46b3-9fd0-01c5a9afbcca"],
+    "riscv32": ["SD_GPT_USR_RISCV32", "b933fb22-5c3f-4f91-af90-e2bb0fa50702"],
+}
+
+rootverity = {
+    # See above for weirdly named partition types
+    "x86": ["SD_GPT_ROOT_X86_VERITY", "d13c5d3b-b5d1-422a-b29f-9454fdc89d76"],
+    "x86_64": ["SD_GPT_ROOT_X86_64_VERITY", "2c7357ed-ebd2-46d9-aec1-23d437ec2bf5"],
+    "armhf": ["SD_GPT_ROOT_ARM_VERITY", "7386cdf2-203c-47a9-a498-f2ecce45a2d6"],
+    "armv7": ["SD_GPT_ROOT_ARM_VERITY", "7386cdf2-203c-47a9-a498-f2ecce45a2d6"],
+    "aarch64": ["SD_GPT_ROOT_ARM64_VERITY", "df3300ce-d69f-4c92-978c-9bfb0f38d820"],
+    "riscv64": ["SD_GPT_ROOT_RISCV64_VERITY", "b6ed5582-440b-4209-b8da-5ff7c419ea3d"],
+    "s390x": ["SD_GPT_ROOT_S390X_VERITY", "b325bfbe-c7be-4ab8-8357-139e652d2f6b"],
+    "ppc64le": ["SD_GPT_ROOT_PPC64_LE_VERITY", "906bd944-4589-4aae-a4e4-dd983917446a"],
+    "armel": ["SD_GPT_ROOT_ARM_VERITY", "7386cdf2-203c-47a9-a498-f2ecce45a2d6"],
+    "loongarch32": [
+        "SD_GPT_ROOT_LOONGARCH64_VERITY",
+        "f3393b22-e9af-4613-a948-9d3bfbd0c535",
+    ],
+    "loongarchx32": [
+        "SD_GPT_ROOT_LOONGARCH64_VERITY",
+        "f3393b22-e9af-4613-a948-9d3bfbd0c535",
+    ],
+    "loongarch64": [
+        "SD_GPT_ROOT_LOONGARCH64_VERITY",
+        "f3393b22-e9af-4613-a948-9d3bfbd0c535",
+    ],
+    "mips": ["SD_GPT_ROOT_MIPS_VERITY", "7a430799-f711-4c7e-8e5b-1d685bd48607"],
+    "mips64": ["SD_GPT_ROOT_MIPS64_VERITY", "579536f8-6a33-4055-a95a-df2d5e2c42a8"],
+    "mipsel": ["SD_GPT_ROOT_MIPS_LE_VERITY", "d7d150d2-2a04-4a33-8f12-16651205ff7b"],
+    "mips64el": ["SD_GPT_ROOT_MIPS64_LE_VERITY", "16b417f8-3e06-4f57-8dd2-9b5232f41aa6"],
+    "ppc": ["SD_GPT_ROOT_PPC_VERITY", "98cfe649-1588-46dc-b2f0-add147424925"],
+    "ppc64": ["SD_GPT_ROOT_PPC64_VERITY", "9225a9a3-3c19-4d89-b4f6-eeff88f17631"],
+    "riscv32": ["SD_GPT_ROOT_RISCV32_VERITY", "ae0253be-1167-4007-ac68-43926c14c5de"],
+}
+
+usrverity = {
+    # See above for weirdly named partition types
+    "x86": ["SD_GPT_USR_X86_VERITY", "8f461b0d-14ee-4e81-9aa9-049b6fb97abd"],
+    "x86_64": ["SD_GPT_USR_X86_64_VERITY", "77ff5f63-e7b6-4633-acf4-1565b864c0e6"],
+    "armhf": ["SD_GPT_USR_ARM_VERITY", "c215d751-7bcd-4649-be90-6627490a4c05"],
+    "armv7": ["SD_GPT_USR_ARM_VERITY", "c215d751-7bcd-4649-be90-6627490a4c05"],
+    "arm64": ["SD_GPT_USR_ARM64_VERITY", "6e11a4e7-fbca-4ded-b9e9-e1a512bb664e"],
+    "riscv64": ["SD_GPT_USR_RISCV64_VERITY", "8f1056be-9b05-47c4-81d6-be53128e5b54"],
+    "s390x": ["SD_GPT_USR_S390X_VERITY", "31741cc4-1a2a-4111-a581-e00b447d2d06"],
+    "ppc64le": ["SD_GPT_USR_PPC64_LE_VERITY", "ee2b9983-21e8-4153-86d9-b6901a54d1ce"],
+    "armel": ["SD_GPT_USR_ARM_VERITY", "c215d751-7bcd-4649-be90-6627490a4c05"],
+    "loongarch32": [
+        "SD_GPT_USR_LOONGARCH64_VERITY",
+        "f46b2c26-59ae-48f0-9106-c50ed47f673d",
+    ],
+    "loongarchx32": [
+        "SD_GPT_USR_LOONGARCH64_VERITY",
+        "f46b2c26-59ae-48f0-9106-c50ed47f673d",
+    ],
+    "loongarch64": [
+        "SD_GPT_USR_LOONGARCH64_VERITY",
+        "f46b2c26-59ae-48f0-9106-c50ed47f673d",
+    ],
+    "mips": ["SD_GPT_USR_MIPS_VERITY", "6e5a1bc8-d223-49b7-bca8-37a5fcceb996"],
+    "mips64": ["SD_GPT_USR_MIPS64_VERITY", "81cf9d90-7458-4df4-8dcf-c8a3a404f09b"],
+    "mipsel": ["SD_GPT_USR_MIPS_LE_VERITY", "46b98d8d-b55c-4e8f-aab3-37fca7f80752"],
+    "mips64el": ["SD_GPT_USR_MIPS64_LE_VERITY", "3c3d61fe-b5f3-414d-bb71-8739a694a4ef"],
+    "ppc": ["SD_GPT_USR_PPC_VERITY", "df765d00-270e-49e5-bc75-f47bb2118b09"],
+    "ppc64": ["SD_GPT_USR_PPC64_VERITY", "bdb528a5-a259-475f-a87d-da53fa736a07"],
+    "riscv32": ["SD_GPT_USR_RISCV32_VERITY", "cb1ee4e3-8cd0-4136-a0a4-aa61a32e8730"],
+}

pmb/core/package_metadata.py

+# Copyright 2024 Stefan Hansson
+# SPDX-License-Identifier: GPL-3.0-or-later
+from dataclasses import dataclass
+from typing import Any
+
+import pmb.build._package
+from pmb.core.apkindex_block import ApkindexBlock
+from pmb.core.context import get_context
+
+
+@dataclass
+class PackageMetadata:
+    # This can't be list[Arch] because it can have values like "noarch" and "!armhf"
+    arch: list[str]
+    depends: list[str]
+    pkgname: str
+    provides: list[str]
+    version: str
+
+    @staticmethod
+    def from_apkindex_block(apkindex_block: ApkindexBlock) -> "PackageMetadata":
+        return PackageMetadata(
+            arch=[str(apkindex_block.arch)],
+            depends=apkindex_block.depends or [],
+            pkgname=apkindex_block.pkgname,
+            provides=apkindex_block.provides,
+            version=apkindex_block.version,
+        )
+
+    @staticmethod
+    def from_pmaport(pmaport: dict[str, Any]) -> "PackageMetadata":
+        pmaport_arches = pmaport["arch"]
+        pmaport_depends = pmb.build._package.get_depends(get_context(), pmaport)
+        pmaport_pkgname = pmaport["pkgname"]
+        pmaport_provides = pmaport["provides"]
+        pmaport_version = pmaport["pkgver"] + "-r" + pmaport["pkgrel"]
+
+        return PackageMetadata(
+            arch=pmaport_arches,
+            depends=pmaport_depends or [],
+            pkgname=pmaport_pkgname,
+            provides=pmaport_provides,
+            version=pmaport_version,
+        )

pmb/helpers/frontend.py

@@ -36,6 +36,7 @@ import pmb.install
 import pmb.install.blockdevice
 import pmb.netboot
 import pmb.parse
+import pmb.parse.apkindex
 import pmb.qemu
 import pmb.sideload
 from pmb.core import ChrootType, Chroot
@@ -490,7 +491,12 @@ def apkindex_parse(args: PmbArgs) -> None:
     if args.package:
         if args.package not in result:
             raise RuntimeError(f"Package not found in the APKINDEX: {args.package}")
-        result = result[args.package]
+        if isinstance(args.package, list):
+            raise AssertionError
+        result_temp = result[args.package]
+        if isinstance(result_temp, pmb.parse.apkindex.ApkindexBlock):
+            raise AssertionError
+        result = result_temp
     print(json.dumps(result, indent=4))