push sheeet

ci/eval/compare/cmp-stats.py

@@ -0,0 +1,317 @@
+import argparse
+import json
+import numpy as np
+import os
+import pandas as pd
+
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from scipy.stats import ttest_rel
+from tabulate import tabulate
+from typing import Final
+
+
+def flatten_data(json_data: dict) -> dict:
+    """
+    Extracts and flattens metrics from JSON data.
+    This is needed because the JSON data can be nested.
+    For example, the JSON data entry might look like this:
+
+    "gc":{"cycles":13,"heapSize":5404549120,"totalBytes":9545876464}
+
+    Flattened:
+
+    "gc.cycles": 13
+    "gc.heapSize": 5404549120
+    ...
+
+    See https://github.com/NixOS/nix/blob/187520ce88c47e2859064704f9320a2d6c97e56e/src/libexpr/eval.cc#L2846
+    for the ultimate source of this data.
+
+    Args:
+        json_data (dict): JSON data containing metrics.
+    Returns:
+        dict: Flattened metrics with keys as metric names.
+    """
+    flat_metrics = {}
+    for key, value in json_data.items():
+        # This key is duplicated as `time.cpu`; we keep that copy.
+        if key == "cpuTime":
+            continue
+
+        if isinstance(value, (int, float)):
+            flat_metrics[key] = value
+        elif isinstance(value, dict):
+            for subkey, subvalue in value.items():
+                assert isinstance(subvalue, (int, float)), subvalue
+                flat_metrics[f"{key}.{subkey}"] = subvalue
+        else:
+            assert isinstance(value, (float, int, dict)), (
+                f"Value `{value}` has unexpected type"
+            )
+
+    return flat_metrics
+
+
+def load_all_metrics(path: Path) -> dict:
+    """
+    Loads all stats JSON files in the specified file or directory and extracts metrics.
+    These stats JSON files are created by Nix when the `NIX_SHOW_STATS` environment variable is set.
+
+    If the provided path is a directory, it must have the structure $path/$system/$stats,
+    where $path is the provided path, $system is some system from `lib.systems.doubles.*`,
+    and $stats is a stats JSON file.
+
+    If the provided path is a file, it is a stats JSON file.
+
+    Args:
+        path (Path): Directory containing JSON files or a stats JSON file.
+
+    Returns:
+        dict: Dictionary with filenames as keys and extracted metrics as values.
+    """
+    metrics = {}
+    if path.is_dir():
+        for system_dir in path.iterdir():
+            assert system_dir.is_dir()
+
+            for chunk_output in system_dir.iterdir():
+                with chunk_output.open() as f:
+                    data = json.load(f)
+
+                metrics[f"{system_dir.name}/${chunk_output.name}"] = flatten_data(data)
+    else:
+        with path.open() as f:
+            metrics[path.name] = flatten_data(json.load(f))
+
+    return metrics
+
+
+def metric_table_name(name: str, explain: bool) -> str:
+    """
+    Returns the name of the metric, plus a footnote to explain it if needed.
+    """
+    return f"{name}[^{name}]" if explain else name
+
+
+METRIC_EXPLANATION_FOOTNOTE: Final[str] = """
+
+[^time.cpu]: Number of seconds of CPU time accounted by the OS to the Nix evaluator process. On UNIX systems, this comes from [`getrusage(RUSAGE_SELF)`](https://man7.org/linux/man-pages/man2/getrusage.2.html).
+[^time.gc]: Number of seconds of CPU time accounted by the Boehm garbage collector to performing GC.
+[^time.gcFraction]: What fraction of the total CPU time is accounted towards performing GC.
+[^gc.cycles]: Number of times garbage collection has been performed.
+[^gc.heapSize]: Size in bytes of the garbage collector heap.
+[^gc.totalBytes]: Size in bytes of all allocations in the garbage collector.
+[^envs.bytes]: Size in bytes of all `Env` objects allocated by the Nix evaluator. These are almost exclusively created by [`nix-env`](https://nix.dev/manual/nix/stable/command-ref/nix-env.html).
+[^list.bytes]: Size in bytes of all [lists](https://nix.dev/manual/nix/stable/language/syntax.html#list-literal) allocated by the Nix evaluator.
+[^sets.bytes]: Size in bytes of all [attrsets](https://nix.dev/manual/nix/stable/language/syntax.html#list-literal) allocated by the Nix evaluator.
+[^symbols.bytes]: Size in bytes of all items in the Nix evaluator symbol table.
+[^values.bytes]: Size in bytes of all values allocated by the Nix evaluator.
+[^envs.number]: The count of all `Env` objects allocated.
+[^nrAvoided]: The number of thunks avoided being created.
+[^nrExprs]: The number of expression objects ever created.
+[^nrFunctionCalls]: The number of function calls ever made.
+[^nrLookups]: The number of lookups into an attrset ever made.
+[^nrOpUpdateValuesCopied]: The number of attrset values copied in the process of merging attrsets.
+[^nrOpUpdates]: The number of attrsets merge operations (`//`) performed.
+[^nrPrimOpCalls]: The number of function calls to primops (Nix builtins) ever made.
+[^nrThunks]: The number of [thunks](https://nix.dev/manual/nix/latest/language/evaluation.html#laziness) ever made. A thunk is a delayed computation, represented by an expression reference and a closure.
+[^sets.number]: The number of attrsets ever made.
+[^symbols.number]: The number of symbols ever added to the symbol table.
+[^values.number]: The number of values ever made.
+[^envs.elements]: The number of values contained within an `Env` object.
+[^list.concats]: The number of list concatenation operations (`++`) performed.
+[^list.elements]: The number of values contained within a list.
+[^sets.elements]: The number of values contained within an attrset.
+[^sizes.Attr]: Size in bytes of the `Attr` type.
+[^sizes.Bindings]: Size in bytes of the `Bindings` type.
+[^sizes.Env]: Size in bytes of the `Env` type.
+[^sizes.Value]: Size in bytes of the `Value` type.
+"""
+
+
+@dataclass(frozen=True)
+class PairwiseTestResults:
+    updated: pd.DataFrame
+    equivalent: pd.DataFrame
+
+    @staticmethod
+    def tabulate(table, headers) -> str:
+        return tabulate(
+            table, headers, tablefmt="github", floatfmt=".4f", missingval="-"
+        )
+
+    def updated_to_markdown(self, explain: bool) -> str:
+        assert not self.updated.empty
+        # Header (get column names and format them)
+        return self.tabulate(
+            headers=[str(column) for column in self.updated.columns],
+            table=[
+                [
+                    # The metric acts as its own footnote name
+                    metric_table_name(row["metric"], explain),
+                    # Check for no change and NaN in p_value/t_stat
+                    *[
+                        None if np.isnan(val) or np.allclose(val, 0) else val
+                        for val in row[1:]
+                    ],
+                ]
+                for _, row in self.updated.iterrows()
+            ],
+        )
+
+    def equivalent_to_markdown(self, explain: bool) -> str:
+        assert not self.equivalent.empty
+        return self.tabulate(
+            headers=[str(column) for column in self.equivalent.columns],
+            table=[
+                [
+                    # The metric acts as its own footnote name
+                    metric_table_name(row["metric"], explain),
+                    row["value"],
+                ]
+                for _, row in self.equivalent.iterrows()
+            ],
+        )
+
+    def to_markdown(self, explain: bool) -> str:
+        result = ""
+
+        if not self.equivalent.empty:
+            result += "## Unchanged values\n\n"
+            result += self.equivalent_to_markdown(explain)
+
+        if not self.updated.empty:
+            result += ("\n\n" if result else "") + "## Updated values\n\n"
+            result += self.updated_to_markdown(explain)
+
+        if explain:
+            result += METRIC_EXPLANATION_FOOTNOTE
+
+        return result
+
+
+@dataclass(frozen=True)
+class Equivalent:
+    metric: str
+    value: float
+
+
+@dataclass(frozen=True)
+class Comparison:
+    metric: str
+    mean_before: float
+    mean_after: float
+    mean_diff: float
+    mean_pct_change: float
+
+
+@dataclass(frozen=True)
+class ComparisonWithPValue(Comparison):
+    p_value: float
+    t_stat: float
+
+
+def metric_sort_key(name: str) -> str:
+    if name in ("time.cpu", "time.gc", "time.gcFraction"):
+        return (1, name)
+    elif name.startswith("gc"):
+        return (2, name)
+    elif name.endswith(("bytes", "Bytes")):
+        return (3, name)
+    elif name.startswith("nr") or name.endswith("number"):
+        return (4, name)
+    else:
+        return (5, name)
+
+
+def perform_pairwise_tests(
+    before_metrics: dict, after_metrics: dict
+) -> PairwiseTestResults:
+    common_files = sorted(set(before_metrics) & set(after_metrics))
+    all_keys = sorted(
+        {
+            metric_keys
+            for file_metrics in before_metrics.values()
+            for metric_keys in file_metrics.keys()
+        },
+        key=metric_sort_key,
+    )
+
+    updated = []
+    equivalent = []
+
+    for key in all_keys:
+        before_vals = []
+        after_vals = []
+
+        for fname in common_files:
+            if key in before_metrics[fname] and key in after_metrics[fname]:
+                before_vals.append(before_metrics[fname][key])
+                after_vals.append(after_metrics[fname][key])
+
+        if len(before_vals) == 0:
+            continue
+
+        before_arr = np.array(before_vals)
+        after_arr = np.array(after_vals)
+
+        diff = after_arr - before_arr
+
+        # If there's no difference, add it all to the equivalent output.
+        if np.allclose(diff, 0):
+            equivalent.append(Equivalent(metric=key, value=before_vals[0]))
+        else:
+            pct_change = 100 * diff / before_arr
+
+            result = Comparison(
+                metric=key,
+                mean_before=np.mean(before_arr),
+                mean_after=np.mean(after_arr),
+                mean_diff=np.mean(diff),
+                mean_pct_change=np.mean(pct_change),
+            )
+
+            # If there are enough values to perform a t-test, do so.
+            if len(before_vals) > 1:
+                t_stat, p_val = ttest_rel(after_arr, before_arr)
+                result = ComparisonWithPValue(
+                    **asdict(result), p_value=p_val, t_stat=t_stat
+                )
+
+            updated.append(result)
+
+    return PairwiseTestResults(
+        updated=pd.DataFrame(map(asdict, updated)),
+        equivalent=pd.DataFrame(map(asdict, equivalent)),
+    )
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Performance comparison of Nix evaluation statistics"
+    )
+    parser.add_argument(
+        "--explain", action="store_true", help="Explain the evaluation statistics"
+    )
+    parser.add_argument(
+        "before", help="File or directory containing baseline (data before)"
+    )
+    parser.add_argument(
+        "after", help="File or directory containing comparison (data after)"
+    )
+
+    options = parser.parse_args()
+
+    before_stats = Path(options.before)
+    after_stats = Path(options.after)
+
+    before_metrics = load_all_metrics(before_stats)
+    after_metrics = load_all_metrics(after_stats)
+    pairwise_test_results = perform_pairwise_tests(before_metrics, after_metrics)
+    markdown_table = pairwise_test_results.to_markdown(explain=options.explain)
+    print(markdown_table)
+
+
+if __name__ == "__main__":
+    main()

ci/eval/compare/default.nix

@@ -0,0 +1,228 @@
+{
+  callPackage,
+  lib,
+  jq,
+  runCommand,
+  writeText,
+  python3,
+  stdenvNoCC,
+  makeWrapper,
+}:
+let
+  python = python3.withPackages (ps: [
+    ps.numpy
+    ps.pandas
+    ps.scipy
+    ps.tabulate
+  ]);
+
+  cmp-stats = stdenvNoCC.mkDerivation {
+    pname = "cmp-stats";
+    version = lib.trivial.release;
+
+    dontUnpack = true;
+
+    nativeBuildInputs = [ makeWrapper ];
+
+    installPhase = ''
+      runHook preInstall
+
+      mkdir -p $out/share/cmp-stats
+
+      cp ${./cmp-stats.py} "$out/share/cmp-stats/cmp-stats.py"
+
+      makeWrapper ${python.interpreter} "$out/bin/cmp-stats" \
+          --add-flags "$out/share/cmp-stats/cmp-stats.py"
+
+      runHook postInstall
+    '';
+
+    meta = {
+      description = "Performance comparison of Nix evaluation statistics";
+      license = lib.licenses.mit;
+      mainProgram = "cmp-stats";
+      maintainers = with lib.maintainers; [ philiptaron ];
+    };
+  };
+in
+{
+  combinedDir,
+  touchedFilesJson,
+  githubAuthorId,
+  byName ? false,
+}:
+let
+  # Usually we expect a derivation, but when evaluating in multiple separate steps, we pass
+  # nix store paths around. These need to be turned into (fake) derivations again to track
+  # dependencies properly.
+  # We use two steps for evaluation, because we compare results from two different checkouts.
+  # CI additionalls spreads evaluation across multiple workers.
+  combined = if lib.isDerivation combinedDir then combinedDir else lib.toDerivation combinedDir;
+
+  /*
+    Derivation that computes which packages are affected (added, changed or removed) between two revisions of nixpkgs.
+    Note: "platforms" are "x86_64-linux", "aarch64-darwin", ...
+
+    ---
+    Inputs:
+    - beforeDir, afterDir: The evaluation result from before and after the change.
+      They can be obtained by running `nix-build -A ci.eval.full` on both revisions.
+
+    ---
+    Outputs:
+      - changed-paths.json: Various information about the changes:
+        {
+          attrdiff: {
+            added: ["package1"],
+            changed: ["package2", "package3"],
+            removed: ["package4"],
+          },
+          labels: {
+            "10.rebuild-darwin: 1-10": true,
+            "10.rebuild-linux: 1-10": true
+          },
+          rebuildsByKernel: {
+            darwin: ["package1", "package2"],
+            linux: ["package1", "package2", "package3"]
+          },
+          rebuildCountByKernel: {
+            darwin: 2,
+            linux: 3,
+          },
+          rebuildsByPlatform: {
+            aarch64-darwin: ["package1", "package2"],
+            aarch64-linux: ["package1", "package2"],
+            x86_64-linux: ["package1", "package2", "package3"],
+            x86_64-darwin: ["package1"],
+          },
+        }
+      - step-summary.md: A markdown render of the changes
+
+    ---
+    Implementation details:
+
+    Helper functions can be found in ./utils.nix.
+    Two main "types" are important:
+
+    - `packagePlatformPath`: A string of the form "<PACKAGE_PATH>.<PLATFORM>"
+      Example: "python312Packages.numpy.x86_64-linux"
+
+    - `packagePlatformAttr`: An attrs representation of a packagePlatformPath:
+      Example: { name = "python312Packages.numpy"; platform = "x86_64-linux"; }
+  */
+  inherit (import ./utils.nix { inherit lib; })
+    groupByKernel
+    convertToPackagePlatformAttrs
+    groupByPlatform
+    extractPackageNames
+    getLabels
+    ;
+
+  # Attrs
+  # - keys: "added", "changed", "removed" and "rebuilds"
+  # - values: lists of `packagePlatformPath`s
+  diffAttrs = builtins.fromJSON (builtins.readFile "${combined}/combined-diff.json");
+
+  changedPackagePlatformAttrs = convertToPackagePlatformAttrs diffAttrs.changed;
+  rebuildsPackagePlatformAttrs = convertToPackagePlatformAttrs diffAttrs.rebuilds;
+  removedPackagePlatformAttrs = convertToPackagePlatformAttrs diffAttrs.removed;
+
+  changed-paths =
+    let
+      rebuildsByPlatform = groupByPlatform rebuildsPackagePlatformAttrs;
+      rebuildsByKernel = groupByKernel rebuildsPackagePlatformAttrs;
+      rebuildCountByKernel = lib.mapAttrs (
+        kernel: kernelRebuilds: lib.length kernelRebuilds
+      ) rebuildsByKernel;
+    in
+    writeText "changed-paths.json" (
+      builtins.toJSON {
+        attrdiff = lib.mapAttrs (_: extractPackageNames) { inherit (diffAttrs) added changed removed; };
+        inherit
+          rebuildsByPlatform
+          rebuildsByKernel
+          rebuildCountByKernel
+          ;
+        labels =
+          getLabels rebuildCountByKernel
+          # Sets "10.rebuild-*-stdenv" label to whether the "stdenv" attribute was changed.
+          // lib.mapAttrs' (
+            kernel: rebuilds: lib.nameValuePair "10.rebuild-${kernel}-stdenv" (lib.elem "stdenv" rebuilds)
+          ) rebuildsByKernel
+          // {
+            "10.rebuild-nixos-tests" =
+              lib.elem "nixosTests.simple" (extractPackageNames diffAttrs.rebuilds)
+              &&
+                # Only set this label when no other label with indication for staging has been set.
+                # This avoids confusion whether to target staging or batch this with kernel updates.
+                lib.last (lib.sort lib.lessThan (lib.attrValues rebuildCountByKernel)) <= 500;
+            # Set the "11.by: package-maintainer" label to whether all packages directly
+            # changed are maintained by the PR's author.
+            "11.by: package-maintainer" =
+              maintainers ? ${githubAuthorId}
+              && lib.all (lib.flip lib.elem maintainers.${githubAuthorId}) (
+                lib.flatten (lib.attrValues maintainers)
+              );
+          };
+      }
+    );
+
+  maintainers = callPackage ./maintainers.nix { } {
+    changedattrs = lib.attrNames (lib.groupBy (a: a.name) changedPackagePlatformAttrs);
+    changedpathsjson = touchedFilesJson;
+    removedattrs = lib.attrNames (lib.groupBy (a: a.name) removedPackagePlatformAttrs);
+    inherit byName;
+  };
+in
+runCommand "compare"
+  {
+    # Don't depend on -dev outputs to reduce closure size for CI.
+    nativeBuildInputs = map lib.getBin [
+      jq
+      cmp-stats
+    ];
+    maintainers = builtins.toJSON maintainers;
+    passAsFile = [ "maintainers" ];
+  }
+  ''
+    mkdir $out
+
+    cp ${changed-paths} $out/changed-paths.json
+
+    {
+      echo
+      echo "# Packages"
+      echo
+      jq -r -f ${./generate-step-summary.jq} < ${changed-paths}
+    } >> $out/step-summary.md
+
+    if jq -e '(.attrdiff.added | length == 0) and (.attrdiff.removed | length == 0)' "${changed-paths}" > /dev/null; then
+      # Chunks have changed between revisions
+      # We cannot generate a performance comparison
+      {
+        echo
+        echo "# Performance comparison"
+        echo
+        echo "This compares the performance of this branch against its pull request base branch (e.g., 'master')"
+        echo
+        echo "For further help please refer to: [ci/README.md](https://github.com/NixOS/nixpkgs/blob/master/ci/README.md)"
+        echo
+      } >> $out/step-summary.md
+
+      cmp-stats --explain ${combined}/before/stats ${combined}/after/stats >> $out/step-summary.md
+
+    else
+      # Package chunks are the same in both revisions
+      # We can use the to generate a performance comparison
+      {
+        echo
+        echo "# Performance Comparison"
+        echo
+        echo "Performance stats were skipped because the package sets differ between the two revisions."
+        echo
+        echo "For further help please refer to: [ci/README.md](https://github.com/NixOS/nixpkgs/blob/master/ci/README.md)"
+      } >> $out/step-summary.md
+    fi
+
+    cp "$maintainersPath" "$out/maintainers.json"
+  ''

ci/eval/compare/generate-step-summary.jq

@@ -0,0 +1,30 @@
+def truncate(xs; n):
+  if xs | length > n then xs[:n] + ["..."]
+  else xs
+  end;
+
+def itemize_packages(xs):
+  truncate(xs; 2000) |
+    map("- [\(.)](https://search.nixos.org/packages?channel=unstable&show=\(.)&from=0&size=50&sort=relevance&type=packages&query=\(.))")  |
+    join("\n");
+
+def get_title(s; xs):
+  s + " (" + (xs | length | tostring) + ")";
+
+def section(title; xs):
+  "<details> <summary>" + get_title(title; xs) + "</summary>\n\n" + itemize_packages(xs) + "</details>";
+
+def fallback_document(content; n):
+  if content | utf8bytelength > n then
+    get_title("Added packages"; .attrdiff.added) + "\n\n" +
+    get_title("Removed packages"; .attrdiff.removed) + "\n\n" +
+    get_title("Changed packages"; .attrdiff.changed)
+  else content
+  end;
+
+# we truncate the list to stay below the GitHub limit of 1MB per step summary.
+fallback_document(
+  section("Added packages"; .attrdiff.added) + "\n\n" +
+  section("Removed packages"; .attrdiff.removed) + "\n\n" +
+  section("Changed packages"; .attrdiff.changed); 1000 * 1000
+)

ci/eval/compare/maintainers.nix

@@ -0,0 +1,98 @@
+{
+  lib,
+}:
+{
+  changedattrs,
+  changedpathsjson,
+  removedattrs,
+  byName ? false,
+}:
+let
+  pkgs = import ../../.. {
+    system = "x86_64-linux";
+    config = { };
+    overlays = [ ];
+  };
+
+  changedpaths = builtins.fromJSON (builtins.readFile changedpathsjson);
+
+  anyMatchingFile =
+    filename: builtins.any (changed: lib.strings.hasSuffix changed filename) changedpaths;
+
+  anyMatchingFiles = files: builtins.any anyMatchingFile files;
+
+  attrsWithMaintainers = lib.pipe (changedattrs ++ removedattrs) [
+    (map (
+      name:
+      let
+        # Some packages might be reported as changed on a different platform, but
+        # not even have an attribute on the platform the maintainers are requested on.
+        # Fallback to `null` for these to filter them out below.
+        package = lib.attrByPath (lib.splitString "." name) null pkgs;
+      in
+      {
+        inherit name package;
+        # TODO: Refactor this so we can ping entire teams instead of the individual members.
+        # Note that this will require keeping track of GH team IDs in "maintainers/teams.nix".
+        maintainers = package.meta.maintainers or [ ];
+      }
+    ))
+    # No need to match up packages without maintainers with their files.
+    # This also filters out attributes where `packge = null`, which is the
+    # case for libintl, for example.
+    (builtins.filter (pkg: pkg.maintainers != [ ]))
+  ];
+
+  relevantFilenames =
+    drv:
+    (lib.lists.unique (
+      map (pos: lib.strings.removePrefix (toString ../..) pos.file) (
+        builtins.filter (x: x != null) [
+          ((drv.meta or { }).maintainersPosition or null)
+          ((drv.meta or { }).teamsPosition or null)
+          (builtins.unsafeGetAttrPos "src" drv)
+          # broken because name is always set by stdenv:
+          #    # A hack to make `nix-env -qa` and `nix search` ignore broken packages.
+          #    # TODO(@oxij): remove this assert when something like NixOS/nix#1771 gets merged into nix.
+          #    name = assert validity.handled; name + lib.optionalString
+          #(builtins.unsafeGetAttrPos "name" drv)
+          (builtins.unsafeGetAttrPos "pname" drv)
+          (builtins.unsafeGetAttrPos "version" drv)
+
+          # Use ".meta.position" for cases when most of the package is
+          # defined in a "common" section and the only place where
+          # reference to the file with a derivation the "pos"
+          # attribute.
+          #
+          # ".meta.position" has the following form:
+          #   "pkgs/tools/package-management/nix/default.nix:155"
+          # We transform it to the following:
+          #   { file = "pkgs/tools/package-management/nix/default.nix"; }
+          { file = lib.head (lib.splitString ":" (drv.meta.position or "")); }
+        ]
+      )
+    ));
+
+  attrsWithFilenames = map (
+    pkg: pkg // { filenames = relevantFilenames pkg.package; }
+  ) attrsWithMaintainers;
+
+  attrsWithModifiedFiles = builtins.filter (pkg: anyMatchingFiles pkg.filenames) attrsWithFilenames;
+
+  listToPing = lib.concatMap (
+    pkg:
+    map (maintainer: {
+      id = maintainer.githubId;
+      inherit (maintainer) github;
+      packageName = pkg.name;
+      dueToFiles = pkg.filenames;
+    }) pkg.maintainers
+  ) attrsWithModifiedFiles;
+
+  byMaintainer = lib.groupBy (ping: toString ping.${if byName then "github" else "id"}) listToPing;
+
+  packagesPerMaintainer = lib.attrsets.mapAttrs (
+    maintainer: packages: map (pkg: pkg.packageName) packages
+  ) byMaintainer;
+in
+packagesPerMaintainer

ci/eval/compare/utils.nix

@@ -0,0 +1,195 @@
+{ lib, ... }:
+rec {
+  # Borrowed from https://github.com/NixOS/nixpkgs/pull/355616
+  uniqueStrings = list: builtins.attrNames (builtins.groupBy lib.id list);
+
+  /*
+    Converts a `packagePlatformPath` into a `packagePlatformAttr`
+
+    Turns
+      "hello.aarch64-linux"
+    into
+      {
+        name = "hello";
+        packagePath = [ "hello" ];
+        platform = "aarch64-linux";
+      }
+  */
+  convertToPackagePlatformAttr =
+    packagePlatformPath:
+    let
+      # python312Packages.numpy.aarch64-linux -> ["python312Packages" "numpy" "aarch64-linux"]
+      splittedPath = lib.splitString "." packagePlatformPath;
+
+      # ["python312Packages" "numpy" "aarch64-linux"] -> ["python312Packages" "numpy"]
+      packagePath = lib.sublist 0 (lib.length splittedPath - 1) splittedPath;
+
+      # "python312Packages.numpy"
+      name = lib.concatStringsSep "." packagePath;
+    in
+    if name == "" then
+      null
+    else
+      {
+        # [ "python312Packages" "numpy" ]
+        inherit packagePath;
+
+        # python312Packages.numpy
+        inherit name;
+
+        # "aarch64-linux"
+        platform = lib.last splittedPath;
+      };
+
+  /*
+    Converts a list of `packagePlatformPath`s into a list of `packagePlatformAttr`s
+
+    Turns
+      [
+        "hello.aarch64-linux"
+        "hello.x86_64-linux"
+        "hello.aarch64-darwin"
+        "hello.x86_64-darwin"
+        "bye.x86_64-darwin"
+        "bye.aarch64-darwin"
+        "release-checks"  <- Will be dropped
+      ]
+    into
+      [
+        { name = "hello"; platform = "aarch64-linux"; packagePath = [ "hello" ]; }
+        { name = "hello"; platform = "x86_64-linux"; packagePath = [ "hello" ]; }
+        { name = "hello"; platform = "aarch64-darwin"; packagePath = [ "hello" ]; }
+        { name = "hello"; platform = "x86_64-darwin"; packagePath = [ "hello" ]; }
+        { name = "bye"; platform = "aarch64-darwin"; packagePath = [ "hello" ]; }
+        { name = "bye"; platform = "x86_64-darwin"; packagePath = [ "hello" ]; }
+      ]
+  */
+  convertToPackagePlatformAttrs =
+    packagePlatformPaths:
+    builtins.filter (x: x != null) (map convertToPackagePlatformAttr packagePlatformPaths);
+
+  /*
+    Converts a list of `packagePlatformPath`s directly to a list of (unique) package names
+
+    Turns
+      [
+        "hello.aarch64-linux"
+        "hello.x86_64-linux"
+        "hello.aarch64-darwin"
+        "hello.x86_64-darwin"
+        "bye.x86_64-darwin"
+        "bye.aarch64-darwin"
+      ]
+    into
+      [
+        "hello"
+        "bye"
+      ]
+  */
+  extractPackageNames =
+    packagePlatformPaths:
+    let
+      packagePlatformAttrs = convertToPackagePlatformAttrs (uniqueStrings packagePlatformPaths);
+    in
+    uniqueStrings (map (p: p.name) packagePlatformAttrs);
+
+  /*
+    Group a list of `packagePlatformAttr`s by platforms
+
+    Turns
+      [
+        { name = "hello"; platform = "aarch64-linux"; ... }
+        { name = "hello"; platform = "x86_64-linux"; ... }
+        { name = "hello"; platform = "aarch64-darwin"; ... }
+        { name = "hello"; platform = "x86_64-darwin"; ... }
+        { name = "bye"; platform = "aarch64-darwin"; ... }
+        { name = "bye"; platform = "x86_64-darwin"; ... }
+      ]
+    into
+      {
+        aarch64-linux = [ "hello" ];
+        x86_64-linux = [ "hello" ];
+        aarch64-darwin = [ "hello" "bye" ];
+        x86_64-darwin = [ "hello" "bye" ];
+      }
+  */
+  groupByPlatform =
+    packagePlatformAttrs:
+    let
+      packagePlatformAttrsByPlatform = builtins.groupBy (p: p.platform) packagePlatformAttrs;
+      extractPackageNames = map (p: p.name);
+    in
+    lib.mapAttrs (_: extractPackageNames) packagePlatformAttrsByPlatform;
+
+  # Turns
+  # [
+  #   { name = "hello"; platform = "aarch64-linux"; ... }
+  #   { name = "hello"; platform = "x86_64-linux"; ... }
+  #   { name = "hello"; platform = "aarch64-darwin"; ... }
+  #   { name = "hello"; platform = "x86_64-darwin"; ... }
+  #   { name = "bye"; platform = "aarch64-darwin"; ... }
+  #   { name = "bye"; platform = "x86_64-darwin"; ... }
+  # ]
+  #
+  # into
+  #
+  # {
+  #   linux = [ "hello" ];
+  #   darwin = [ "hello" "bye" ];
+  # }
+  groupByKernel =
+    packagePlatformAttrs:
+    let
+      filterKernel =
+        kernel:
+        builtins.attrNames (
+          builtins.groupBy (p: p.name) (
+            builtins.filter (p: lib.hasSuffix kernel p.platform) packagePlatformAttrs
+          )
+        );
+    in
+    lib.genAttrs [ "linux" "darwin" ] filterKernel;
+
+  /*
+    Maps an attrs of `kernel - rebuild counts` mappings to an attrs of labels
+
+    Turns
+      {
+        linux = 56;
+        darwin = 1;
+      }
+    into
+      {
+        "10.rebuild-darwin: 1" = true;
+        "10.rebuild-darwin: 1-10" = true;
+        "10.rebuild-darwin: 11-100" = false;
+        # [...]
+        "10.rebuild-darwin: 1" = false;
+        "10.rebuild-darwin: 1-10" = false;
+        "10.rebuild-linux: 11-100" = true;
+        # [...]
+      }
+  */
+  getLabels =
+    rebuildCountByKernel:
+    lib.mergeAttrsList (
+      lib.mapAttrsToList (
+        kernel: rebuildCount:
+        let
+          range = from: to: from <= rebuildCount && (to == null || rebuildCount <= to);
+        in
+        lib.mapAttrs' (number: lib.nameValuePair "10.rebuild-${kernel}: ${number}") {
+          "0" = range 0 0;
+          "1" = range 1 1;
+          "1-10" = range 1 10;
+          "11-100" = range 11 100;
+          "101-500" = range 101 500;
+          "501-1000" = range 501 1000;
+          "501+" = range 501 null;
+          "1001-2500" = range 1001 2500;
+          "2501-5000" = range 2501 5000;
+          "5001+" = range 5001 null;
+        }
+      ) rebuildCountByKernel
+    );
+}