Merge pull request #265764 from amjoseph-nixpkgs/pr/pythonForBuild

doc/languages-frameworks/python.section.md

···
 
 The `buildPythonPackage` mainly does four things:
 
-* In the [`buildPhase`](#build-phase), it calls `${python.pythonForBuild.interpreter} setup.py bdist_wheel` to
+* In the [`buildPhase`](#build-phase), it calls `${python.pythonOnBuildForHost.interpreter} setup.py bdist_wheel` to
   build a wheel binary zipfile.
 * In the [`installPhase`](#ssec-install-phase), it installs the wheel file using `pip install *.whl`.
 * In the [`postFixup`](#var-stdenv-postFixup) phase, the `wrapPythonPrograms` bash function is called to
···
 As workaround install it as an extra `preInstall` step:
 
 ```shell
-${python.pythonForBuild.interpreter} setup.py install_data --install-dir=$out --root=$out
+${python.pythonOnBuildForHost.interpreter} setup.py install_data --install-dir=$out --root=$out
 sed -i '/ = data\_files/d' setup.py
 ```
 

nixos/modules/programs/fish.nix

···
             ''
               mkdir -p $out
               if [ -d $package/share/man ]; then
-                find $package/share/man -type f | xargs ${pkgs.python3.pythonForBuild.interpreter} ${patchedGenerator}/create_manpage_completions.py --directory $out >/dev/null
+                find $package/share/man -type f | xargs ${pkgs.python3.pythonOnBuildForHost.interpreter} ${patchedGenerator}/create_manpage_completions.py --directory $out >/dev/null
               fi
             '';
         in

pkgs/applications/misc/calibre/default.nix

···
     export XDG_DATA_HOME=$out/share
     export XDG_UTILS_INSTALL_MODE="user"
 
-    ${python3Packages.python.pythonForBuild.interpreter} setup.py install --root=$out \
+    ${python3Packages.python.pythonOnBuildForHost.interpreter} setup.py install --root=$out \
       --prefix=$out \
       --libdir=$out/lib \
       --staging-root=$out \

pkgs/applications/misc/tandoor-recipes/default.nix

···
     touch cookbook/static/themes/bootstrap.min.css.map
     touch cookbook/static/css/bootstrap-vue.min.css.map
 
-    ${python.pythonForBuild.interpreter} manage.py collectstatic_js_reverse
-    ${python.pythonForBuild.interpreter} manage.py collectstatic
+    ${python.pythonOnBuildForHost.interpreter} manage.py collectstatic_js_reverse
+    ${python.pythonOnBuildForHost.interpreter} manage.py collectstatic
 
     runHook postBuild
   '';

pkgs/applications/misc/zathura/core/default.nix

···
   ];
 
   nativeBuildInputs = [
-    meson ninja pkg-config desktop-file-utils python3.pythonForBuild.pkgs.sphinx
+    meson ninja pkg-config desktop-file-utils python3.pythonOnBuildForHost.pkgs.sphinx
     gettext wrapGAppsHook libxml2 appstream-glib
   ];
 

pkgs/applications/networking/browsers/chromium/common.nix

···
 buildFun:
 
 let
-  python3WithPackages = python3.pythonForBuild.withPackages(ps: with ps; [
+  python3WithPackages = python3.pythonOnBuildForHost.withPackages(ps: with ps; [
     ply jinja2 setuptools
   ]);
   clangFormatPython3 = fetchurl {
···
 
       # This is to ensure expansion of $out.
       libExecPath="${libExecPath}"
-      ${python3.pythonForBuild}/bin/python3 build/linux/unbundle/replace_gn_files.py --system-libraries ${toString gnSystemLibraries}
+      ${python3.pythonOnBuildForHost}/bin/python3 build/linux/unbundle/replace_gn_files.py --system-libraries ${toString gnSystemLibraries}
       ${gnChromium}/bin/gn gen --args=${lib.escapeShellArg gnFlags} out/Release | tee gn-gen-outputs.txt
 
       # Fail if `gn gen` contains a WARNING.

pkgs/applications/networking/flent/default.nix

···
 
     cat >test-runner <<EOF
     #!/bin/sh
-    ${python.pythonForBuild.interpreter} nix_run_setup test
+    ${python.pythonOnBuildForHost.interpreter} nix_run_setup test
     EOF
     chmod +x test-runner
     wrapQtApp test-runner --prefix PYTHONPATH : $PYTHONPATH

pkgs/applications/networking/instant-messengers/deltachat-cursed/default.nix

···
     hash = "sha256-1QNhNPa6ZKn0lGQXs/cmfdSFHscwlYwFC/2DpnMoHvY=";
   };
 
-  nativeBuildInputs = with python3.pythonForBuild.pkgs; [
+  nativeBuildInputs = with python3.pythonOnBuildForHost.pkgs; [
     setuptools
     setuptools-scm
   ];

pkgs/applications/networking/mailreaders/afew/default.nix

···
   outputs = [ "out" "doc" ];
 
   postBuild =  ''
-    ${python3Packages.python.pythonForBuild.interpreter} setup.py build_sphinx -b html,man
+    ${python3Packages.python.pythonOnBuildForHost.interpreter} setup.py build_sphinx -b html,man
   '';
 
   postInstall = ''

pkgs/applications/networking/p2p/zeronet-conservancy/default.nix

···
 
   buildPhase = ''
     runHook preBuild
-    ${python3Packages.python.pythonForBuild.interpreter} -O -m compileall .
+    ${python3Packages.python.pythonOnBuildForHost.interpreter} -O -m compileall .
     runHook postBuild
   '';
 

pkgs/applications/networking/p2p/zeronet/default.nix

···
   ];
 
   buildPhase = ''
-    ${python3Packages.python.pythonForBuild.interpreter} -O -m compileall .
+    ${python3Packages.python.pythonOnBuildForHost.interpreter} -O -m compileall .
   '';
 
   installPhase = ''

pkgs/applications/office/paperless-ngx/default.nix

···
   postBuild = ''
     # Compile manually because `pythonRecompileBytecodeHook` only works
     # for files in `python.sitePackages`
-    ${python.pythonForBuild.interpreter} -OO -m compileall src
+    ${python.pythonOnBuildForHost.interpreter} -OO -m compileall src
 
     # Collect static files
-    ${python.pythonForBuild.interpreter} src/manage.py collectstatic --clear --no-input
+    ${python.pythonOnBuildForHost.interpreter} src/manage.py collectstatic --clear --no-input
 
     # Compile string translations using gettext
-    ${python.pythonForBuild.interpreter} src/manage.py compilemessages
+    ${python.pythonOnBuildForHost.interpreter} src/manage.py compilemessages
   '';
 
   installPhase = ''

pkgs/applications/science/biology/quast/default.nix

···
       --replace "/bin/bash" "${bash}/bin/bash"
     mkdir -p "$out/${python.sitePackages}"
     export PYTHONPATH="$out/${python.sitePackages}:$PYTHONPATH"
-    ${python.pythonForBuild.interpreter} setup.py install \
+    ${python.pythonOnBuildForHost.interpreter} setup.py install \
       --install-lib=$out/${python.sitePackages} \
       --prefix="$out"
   '';

pkgs/applications/science/logic/z3/default.nix

···
 
     configurePhase = concatStringsSep " "
       (
-        [ "${python.pythonForBuild.interpreter} scripts/mk_make.py --prefix=$out" ]
+        [ "${python.pythonOnBuildForHost.interpreter} scripts/mk_make.py --prefix=$out" ]
           ++ optional javaBindings "--java"
           ++ optional ocamlBindings "--ml"
           ++ optional pythonBindings "--python --pypkgdir=$out/${python.sitePackages}"

pkgs/applications/terminal-emulators/kitty/default.nix

···
     runHook preBuild
     ${ lib.optionalString (stdenv.isDarwin && stdenv.isx86_64) "export MACOSX_DEPLOYMENT_TARGET=11" }
     ${if stdenv.isDarwin then ''
-      ${python.pythonForBuild.interpreter} setup.py build ${darwinOptions}
+      ${python.pythonOnBuildForHost.interpreter} setup.py build ${darwinOptions}
       make docs
-      ${python.pythonForBuild.interpreter} setup.py kitty.app ${darwinOptions}
+      ${python.pythonOnBuildForHost.interpreter} setup.py kitty.app ${darwinOptions}
     '' else ''
-      ${python.pythonForBuild.interpreter} setup.py linux-package \
+      ${python.pythonOnBuildForHost.interpreter} setup.py linux-package \
       --egl-library='${lib.getLib libGL}/lib/libEGL.so.1' \
       --startup-notification-library='${libstartup_notification}/lib/libstartup-notification-1.so' \
       --canberra-library='${libcanberra}/lib/libcanberra.so' \
       --fontconfig-library='${fontconfig.lib}/lib/libfontconfig.so' \
       ${commonOptions}
-      ${python.pythonForBuild.interpreter} setup.py build-launcher
+      ${python.pythonOnBuildForHost.interpreter} setup.py build-launcher
     ''}
     runHook postBuild
   '';

pkgs/development/interpreters/python/cpython/2.7/default.nix

···
 
 let
   buildPackages = pkgsBuildHost;
-  inherit (passthru) pythonForBuild;
+  inherit (passthru) pythonOnBuildForHost;
 
-  pythonForBuildInterpreter = if stdenv.hostPlatform == stdenv.buildPlatform then
+  pythonOnBuildForHostInterpreter = if stdenv.hostPlatform == stdenv.buildPlatform then
     "$out/bin/python"
-  else pythonForBuild.interpreter;
+  else pythonOnBuildForHost.interpreter;
 
   passthru = passthruFun rec {
     inherit self sourceVersion packageOverrides;
···
         # We build 3 levels of optimized bytecode. Note the default level, without optimizations,
         # is not reproducible yet. https://bugs.python.org/issue29708
         # Not creating bytecode will result in a large performance loss however, so we do build it.
-        find $out -name "*.py" | ${pythonForBuildInterpreter} -m compileall -q -f -x "lib2to3" -i -
-        find $out -name "*.py" | ${pythonForBuildInterpreter} -O  -m compileall -q -f -x "lib2to3" -i -
-        find $out -name "*.py" | ${pythonForBuildInterpreter} -OO -m compileall -q -f -x "lib2to3" -i -
+        find $out -name "*.py" | ${pythonOnBuildForHostInterpreter} -m compileall -q -f -x "lib2to3" -i -
+        find $out -name "*.py" | ${pythonOnBuildForHostInterpreter} -O  -m compileall -q -f -x "lib2to3" -i -
+        find $out -name "*.py" | ${pythonOnBuildForHostInterpreter} -OO -m compileall -q -f -x "lib2to3" -i -
       '' + lib.optionalString stdenv.hostPlatform.isCygwin ''
         cp libpython2.7.dll.a $out/lib
       '';

pkgs/development/interpreters/python/cpython/default.nix

···
   openssl' = if openssl != null then openssl_legacy else null;
 
   buildPackages = pkgsBuildHost;
-  inherit (passthru) pythonForBuild;
+  inherit (passthru) pythonOnBuildForHost;
 
   inherit (darwin.apple_sdk.frameworks) Cocoa;
 
···
     nukeReferences
   ] ++ optionals (stdenv.hostPlatform != stdenv.buildPlatform) [
     buildPackages.stdenv.cc
-    pythonForBuild
+    pythonOnBuildForHost
   ] ++ optionals (stdenv.cc.isClang && (!stdenv.hostPlatform.useAndroidPrebuilt or false) && (enableLTO || enableOptimizations)) [
     stdenv.cc.cc.libllvm.out
   ];
···
 
   hasDistutilsCxxPatch = !(stdenv.cc.isGNU or false);
 
-  pythonForBuildInterpreter = if stdenv.hostPlatform == stdenv.buildPlatform then
+  pythonOnBuildForHostInterpreter = if stdenv.hostPlatform == stdenv.buildPlatform then
     "$out/bin/python"
-  else pythonForBuild.interpreter;
+  else pythonOnBuildForHost.interpreter;
 
   src = fetchurl {
     url = with sourceVersion; "https://www.python.org/ftp/python/${major}.${minor}.${patch}/Python-${version}.tar.xz";
···
     "ac_cv_file__dev_ptmx=${if stdenv.hostPlatform.isWindows then "no" else "yes"}"
     "ac_cv_file__dev_ptc=${if stdenv.hostPlatform.isWindows then "no" else "yes"}"
   ] ++ optionals (stdenv.hostPlatform != stdenv.buildPlatform && pythonAtLeast "3.11") [
-    "--with-build-python=${pythonForBuildInterpreter}"
+    "--with-build-python=${pythonOnBuildForHostInterpreter}"
   ] ++ optionals stdenv.hostPlatform.isLinux [
     # Never even try to use lchmod on linux,
     # don't rely on detecting glibc-isms.
···
     # We build 3 levels of optimized bytecode. Note the default level, without optimizations,
     # is not reproducible yet. https://bugs.python.org/issue29708
     # Not creating bytecode will result in a large performance loss however, so we do build it.
-    find $out -name "*.py" | ${pythonForBuildInterpreter} -m compileall -q -f -x "lib2to3" -i -
-    find $out -name "*.py" | ${pythonForBuildInterpreter} -O  -m compileall -q -f -x "lib2to3" -i -
-    find $out -name "*.py" | ${pythonForBuildInterpreter} -OO -m compileall -q -f -x "lib2to3" -i -
+    find $out -name "*.py" | ${pythonOnBuildForHostInterpreter} -m compileall -q -f -x "lib2to3" -i -
+    find $out -name "*.py" | ${pythonOnBuildForHostInterpreter} -O  -m compileall -q -f -x "lib2to3" -i -
+    find $out -name "*.py" | ${pythonOnBuildForHostInterpreter} -OO -m compileall -q -f -x "lib2to3" -i -
     '' + ''
     # *strip* shebang from libpython gdb script - it should be dual-syntax and
     # interpretable by whatever python the gdb in question is using, which may
···
     ++ lib.optionals (stdenv.hostPlatform != stdenv.buildPlatform) [
     # Ensure we don't have references to build-time packages.
     # These typically end up in shebangs.
-    pythonForBuild buildPackages.bash
+    pythonOnBuildForHost buildPackages.bash
   ];
 
   separateDebugInfo = true;

pkgs/development/interpreters/python/hooks/default.nix

···
 self: dontUse: with self;
 
 let
-  inherit (python) pythonForBuild;
-  pythonInterpreter = pythonForBuild.interpreter;
+  inherit (python) pythonOnBuildForHost;
+  pythonInterpreter = pythonOnBuildForHost.interpreter;
   pythonSitePackages = python.sitePackages;
   pythonCheckInterpreter = python.interpreter;
   setuppy = ../run_setup.py;
···
       #   set, but in downstream projects that build packages depending on other
       #   versions of this hook's dependencies.
       passthru.tests = import ./pypa-build-hook-tests.nix {
-        inherit pythonForBuild runCommand;
+        inherit pythonOnBuildForHost runCommand;
       };
     } ./pypa-build-hook.sh) {
-      inherit (pythonForBuild.pkgs) build;
+      inherit (pythonOnBuildForHost.pkgs) build;
     };
 
   pipInstallHook = callPackage ({ makePythonHook, pip }:
···
         inherit pythonInterpreter pythonSitePackages;
       };
     } ./pypa-install-hook.sh) {
-      inherit (pythonForBuild.pkgs) installer;
+      inherit (pythonOnBuildForHost.pkgs) installer;
     };
 
   pytestCheckHook = callPackage ({ makePythonHook, pytest }:
···
   sphinxHook = callPackage ({ makePythonHook, installShellFiles }:
     makePythonHook {
       name = "python${python.pythonVersion}-sphinx-hook";
-      propagatedBuildInputs = [ pythonForBuild.pkgs.sphinx installShellFiles ];
+      propagatedBuildInputs = [ pythonOnBuildForHost.pkgs.sphinx installShellFiles ];
     } ./sphinx-hook.sh) {};
 }

pkgs/development/interpreters/python/hooks/pypa-build-hook-test.nix

···
-{ pythonForBuild, runCommand }: {
+{ pythonOnBuildForHost, runCommand }: {
   dont-propagate-conflicting-deps = let
     # customize a package so that its store paths differs
     mkConflict = pkg: pkg.overrideAttrs { some_modification = true; };
···
     '';
     in
     # this build must never triger conflicts
-    pythonForBuild.pkgs.buildPythonPackage {
+    pythonOnBuildForHost.pkgs.buildPythonPackage {
       pname = "dont-propagate-conflicting-deps";
       version = "0.0.0";
       src = projectSource;
···
       propagatedBuildInputs = [
         # At least one dependency of `build` should be included here to
         # keep the test meaningful
-        (mkConflict pythonForBuild.pkgs.tomli)
+        (mkConflict pythonOnBuildForHost.pkgs.tomli)
         # setuptools is also needed to build the example project
-        pythonForBuild.pkgs.setuptools
+        pythonOnBuildForHost.pkgs.setuptools
       ];
     };
 }

pkgs/development/interpreters/python/mk-python-derivation.nix

···
     ] ++ lib.optionals (format' == "pyproject") [(
       if isBootstrapPackage then
         pypaBuildHook.override {
-          inherit (python.pythonForBuild.pkgs.bootstrap) build;
+          inherit (python.pythonOnBuildForHost.pkgs.bootstrap) build;
           wheel = null;
         }
       else
···
     ] ++ lib.optionals (format' != "other") [(
       if isBootstrapInstallPackage then
         pypaInstallHook.override {
-          inherit (python.pythonForBuild.pkgs.bootstrap) installer;
+          inherit (python.pythonOnBuildForHost.pkgs.bootstrap) installer;
         }
       else
         pypaInstallHook
···
     '' + attrs.postFixup or "";
 
     # Python packages built through cross-compilation are always for the host platform.
-    disallowedReferences = lib.optionals (python.stdenv.hostPlatform != python.stdenv.buildPlatform) [ python.pythonForBuild ];
+    disallowedReferences = lib.optionals (python.stdenv.hostPlatform != python.stdenv.buildPlatform) [ python.pythonOnBuildForHost ];
 
     outputs = outputs ++ lib.optional withDistOutput "dist";
 

pkgs/development/interpreters/python/passthrufun.nix

···
     pythonAtLeast = lib.versionAtLeast pythonVersion;
     pythonOlder = lib.versionOlder pythonVersion;
     inherit hasDistutilsCxxPatch;
-    # TODO: deprecate
-    # Not done immediately because its likely used outside Nixpkgs.
-    pythonForBuild = pythonOnBuildForHost_overridden;
+    # Remove after 24.11 is released.
+    pythonForBuild =
+      lib.warnIf (lib.isInOldestRelease 2311) "`pythonForBuild` (from `python*`) has been renamed to `pythonOnBuildForHost`"
+        pythonOnBuildForHost_overridden;
     pythonOnBuildForHost = pythonOnBuildForHost_overridden;
 
     tests = callPackage ./tests.nix {

pkgs/development/interpreters/python/python2/mk-python-derivation.nix

···
     '' + attrs.postFixup or "";
 
     # Python packages built through cross-compilation are always for the host platform.
-    disallowedReferences = lib.optionals (python.stdenv.hostPlatform != python.stdenv.buildPlatform) [ python.pythonForBuild ];
+    disallowedReferences = lib.optionals (python.stdenv.hostPlatform != python.stdenv.buildPlatform) [ python.pythonOnBuildForHost ];
 
     outputs = outputs ++ lib.optional withDistOutput "dist";
 

pkgs/development/interpreters/python/wrap-python.nix

···
       propagatedBuildInputs = [ makeWrapper ];
       substitutions.sitePackages = python.sitePackages;
       substitutions.executable = python.interpreter;
-      substitutions.python = python.pythonForBuild;
+      substitutions.python = python.pythonOnBuildForHost;
       substitutions.pythonHost = python;
       substitutions.magicalSedExpression = let
         # Looks weird? Of course, it's between single quoted shell strings.

pkgs/development/interpreters/renpy/default.nix

···
 
   buildPhase = with python3.pkgs; ''
     runHook preBuild
-    ${python.pythonForBuild.interpreter} module/setup.py build --parallel=$NIX_BUILD_CORES
+    ${python.pythonOnBuildForHost.interpreter} module/setup.py build --parallel=$NIX_BUILD_CORES
     runHook postBuild
   '';
 
   installPhase = with python3.pkgs; ''
     runHook preInstall
 
-    ${python.pythonForBuild.interpreter} module/setup.py install_lib -d $out/${python.sitePackages}
+    ${python.pythonOnBuildForHost.interpreter} module/setup.py install_lib -d $out/${python.sitePackages}
     mkdir -p $out/share/renpy
     cp -vr sdk-fonts gui launcher renpy the_question tutorial renpy.py $out/share/renpy
 

pkgs/development/libraries/gexiv2/default.nix

···
     gtk-doc
     docbook-xsl-nons
     docbook_xml_dtd_43
-    (python3.pythonForBuild.withPackages (ps: [ ps.pygobject3 ]))
+    (python3.pythonOnBuildForHost.withPackages (ps: [ ps.pygobject3 ]))
   ] ++ lib.optionals (!stdenv.buildPlatform.canExecute stdenv.hostPlatform) [
     mesonEmulatorHook
   ];

pkgs/development/libraries/gpgme/default.nix

···
     pkg-config
     texinfo
   ] ++ lib.optionals pythonSupport [
-    python3.pythonForBuild
+    python3.pythonOnBuildForHost
     ncurses
     swig2
     which

pkgs/development/libraries/gusb/default.nix

···
 }:
 
 let
-  pythonEnv = python3.pythonForBuild.withPackages (ps: with ps; [
+  pythonEnv = python3.pythonOnBuildForHost.withPackages (ps: with ps; [
     setuptools
   ]);
 in

pkgs/development/libraries/libftdi/1.x.nix

···
     "-DPYTHON_BINDINGS=${onOff pythonSupport}"
     "-DDOCUMENTATION=${onOff docSupport}"
   ] ++ lib.optionals pythonSupport [
-    "-DPYTHON_EXECUTABLE=${python3.pythonForBuild.interpreter}"
+    "-DPYTHON_EXECUTABLE=${python3.pythonOnBuildForHost.interpreter}"
     "-DPYTHON_LIBRARY=${python3}/lib/libpython${python3.pythonVersion}${stdenv.hostPlatform.extensions.sharedLibrary}"
   ];
 

pkgs/development/libraries/libgweather/default.nix

···
     pkg-config
     gettext
     glib
-    (python3.pythonForBuild.withPackages (ps: [ ps.pygobject3 ]))
+    (python3.pythonOnBuildForHost.withPackages (ps: [ ps.pygobject3 ]))
   ] ++ lib.optionals withIntrospection [
     gi-docgen
     gobject-introspection

pkgs/development/libraries/libical/default.nix

···
   ];
   nativeInstallCheckInputs = [
     # running libical-glib tests
-    (python3.pythonForBuild.withPackages (pkgs: with pkgs; [
+    (python3.pythonOnBuildForHost.withPackages (pkgs: with pkgs; [
       pygobject3
     ]))
   ];

pkgs/development/libraries/libiio/default.nix

···
     "-DOSX_PACKAGE=off"
     "-DOSX_FRAMEWORK=off"
   ] ++ lib.optionals pythonSupport [
-    "-DPython_EXECUTABLE=${python.pythonForBuild.interpreter}"
+    "-DPython_EXECUTABLE=${python.pythonOnBuildForHost.interpreter}"
     "-DPYTHON_BINDINGS=on"
   ] ++ lib.optionals (!avahiSupport) [
     "-DHAVE_DNS_SD=OFF"

pkgs/development/libraries/libxml2/default.nix

···
     (lib.enableFeature enableShared "shared")
     (lib.withFeature icuSupport "icu")
     (lib.withFeature pythonSupport "python")
-    (lib.optionalString pythonSupport "PYTHON=${python.pythonForBuild.interpreter}")
+    (lib.optionalString pythonSupport "PYTHON=${python.pythonOnBuildForHost.interpreter}")
   ];
 
   installFlags = lib.optionals pythonSupport [

pkgs/development/libraries/libxslt/default.nix

···
     "--without-mem-debug"
     "--without-debugger"
     (lib.withFeature pythonSupport "python")
-    (lib.optionalString pythonSupport "PYTHON=${python.pythonForBuild.interpreter}")
+    (lib.optionalString pythonSupport "PYTHON=${python.pythonOnBuildForHost.interpreter}")
   ] ++ lib.optionals (!cryptoSupport) [
     "--without-crypto"
   ];

pkgs/development/libraries/lirc/default.nix

···
 }:
 
 let
-  pythonEnv = python3.pythonForBuild.withPackages (p: with p; [ pyyaml setuptools ]);
+  pythonEnv = python3.pythonOnBuildForHost.withPackages (p: with p; [ pyyaml setuptools ]);
 in
 stdenv.mkDerivation rec {
   pname = "lirc";

pkgs/development/libraries/pipewire/wireplumber.nix

···
     gobject-introspection
   ] ++ lib.optionals (enableDocs || enableGI) [
     doxygen
-    (python3.pythonForBuild.withPackages (ps: with ps;
+    (python3.pythonOnBuildForHost.withPackages (ps: with ps;
       lib.optionals enableDocs [ sphinx sphinx-rtd-theme breathe ]
       ++ lib.optionals enableGI [ lxml ]
     ))

pkgs/development/libraries/polkit/default.nix

···
 
   nativeCheckInputs = [
     dbus
-    (python3.pythonForBuild.withPackages (pp: with pp; [
+    (python3.pythonOnBuildForHost.withPackages (pp: with pp; [
       dbus-python
       (python-dbusmock.overridePythonAttrs (attrs: {
         # Avoid dependency cycle.

pkgs/development/libraries/science/chemistry/openmm/default.nix

···
       export OPENMM_LIB_PATH=$out/lib
       export OPENMM_INCLUDE_PATH=$out/include
       cd python
-      ${python3Packages.python.pythonForBuild.interpreter} setup.py build
-      ${python3Packages.python.pythonForBuild.interpreter} setup.py install --prefix=$out
+      ${python3Packages.python.pythonOnBuildForHost.interpreter} setup.py build
+      ${python3Packages.python.pythonOnBuildForHost.interpreter} setup.py install --prefix=$out
     '';
 
   postFixup = ''

pkgs/development/libraries/science/math/or-tools/default.nix

···
     "-DFETCH_PYTHON_DEPS=OFF"
     "-DUSE_GLPK=ON"
     "-DUSE_SCIP=OFF"
-    "-DPython3_EXECUTABLE=${python.pythonForBuild.interpreter}"
+    "-DPython3_EXECUTABLE=${python.pythonOnBuildForHost.interpreter}"
   ] ++ lib.optionals stdenv.isDarwin [ "-DCMAKE_MACOSX_RPATH=OFF" ];
   nativeBuildInputs = [
     cmake
     ensureNewerSourcesForZipFilesHook
     pkg-config
-    python.pythonForBuild
+    python.pythonOnBuildForHost
     swig4
     unzip
-  ] ++ (with python.pythonForBuild.pkgs; [
+  ] ++ (with python.pythonOnBuildForHost.pkgs; [
     pip
     mypy-protobuf
   ]);

pkgs/development/libraries/tracker/default.nix

···
     wrapGAppsNoGuiHook
     gi-docgen
     graphviz
-    (python3.pythonForBuild.withPackages (p: [ p.pygobject3 ]))
+    (python3.pythonOnBuildForHost.withPackages (p: [ p.pygobject3 ]))
   ] ++ lib.optionals withIntrospection [
     gobject-introspection
     vala

pkgs/development/python-modules/asyncinotify/default.nix

···
   ];
 
   checkPhase = ''
-    ${python.pythonForBuild.interpreter} ${src}/test.py
+    ${python.pythonOnBuildForHost.interpreter} ${src}/test.py
   '';
   pythonImportsCheck = ["asyncinotify"];
 

pkgs/development/python-modules/bash_kernel/default.nix

···
   '';
 
   postInstall = ''
-    ${python.pythonForBuild.interpreter} -m bash_kernel.install --prefix $out
+    ${python.pythonOnBuildForHost.interpreter} -m bash_kernel.install --prefix $out
   '';
 
   meta = with lib; {

pkgs/development/python-modules/bashlex/default.nix

···
 
   # workaround https://github.com/idank/bashlex/issues/51
   preBuild = ''
-    ${python.pythonForBuild.interpreter} -c 'import bashlex'
+    ${python.pythonOnBuildForHost.interpreter} -c 'import bashlex'
   '';
 
   nativeCheckInputs = [

pkgs/development/python-modules/catboost/default.nix

···
     runHook preBuild
 
     # these arguments must set after bdist_wheel
-    ${python.pythonForBuild.interpreter} setup.py bdist_wheel --no-widget --prebuilt-extensions-build-root-dir=${lib.getDev catboost}
+    ${python.pythonOnBuildForHost.interpreter} setup.py bdist_wheel --no-widget --prebuilt-extensions-build-root-dir=${lib.getDev catboost}
 
     runHook postBuild
   '';

pkgs/development/python-modules/cypari2/default.nix

···
 
   nativeBuildInputs = [
     pari
-    python.pythonForBuild.pkgs.pip
+    python.pythonOnBuildForHost.pkgs.pip
   ];
 
   buildInputs = [

pkgs/development/python-modules/dbus/default.nix

···
   '';
 
   configureFlags = [
-    "PYTHON=${python.pythonForBuild.interpreter}"
+    "PYTHON=${python.pythonOnBuildForHost.interpreter}"
   ];
 
   nativeBuildInputs = [ pkg-config ];

pkgs/development/python-modules/gst-python/default.nix

···
   mesonFlags = [
     "-Dpygi-overrides-dir=${placeholder "out"}/${python.sitePackages}/gi/overrides"
     # Exec format error during configure
-    "-Dpython=${python.pythonForBuild.interpreter}"
+    "-Dpython=${python.pythonOnBuildForHost.interpreter}"
   ];
 
   doCheck = true;

pkgs/development/python-modules/llfuse/default.nix

···
   '';
 
   preBuild = ''
-    ${python.pythonForBuild.interpreter} setup.py build_cython
+    ${python.pythonOnBuildForHost.interpreter} setup.py build_cython
   '';
 
   # On Darwin, the test requires macFUSE to be installed outside of Nix.

pkgs/development/python-modules/manimpango/default.nix

···
   '';
 
   preBuild = ''
-    ${python.pythonForBuild.interpreter} setup.py build_ext --inplace
+    ${python.pythonOnBuildForHost.interpreter} setup.py build_ext --inplace
   '';
 
   pythonImportsCheck = [

pkgs/development/python-modules/mutagen/default.nix

···
   ];
 
   postInstall = ''
-    ${python.pythonForBuild.interpreter} setup.py build_sphinx --build-dir=$doc
+    ${python.pythonOnBuildForHost.interpreter} setup.py build_sphinx --build-dir=$doc
   '';
 
   nativeCheckInputs = [

pkgs/development/python-modules/nose/default.nix

···
   '';
 
   preBuild = lib.optionalString (isPy3k) ''
-    ${python.pythonForBuild}/bin/2to3 -wn nose functional_tests unit_tests
+    ${python.pythonOnBuildForHost}/bin/2to3 -wn nose functional_tests unit_tests
   '';
 
   propagatedBuildInputs = [ coverage ];
 
   doCheck = false; # lot's of transient errors, too much hassle
   checkPhase = if isPy3k then ''
-    ${python.pythonForBuild.interpreter} setup.py build_tests
+    ${python.pythonOnBuildForHost.interpreter} setup.py build_tests
   '' else "" + ''
     rm functional_tests/test_multiprocessing/test_concurrent_shared.py* # see https://github.com/nose-devs/nose/commit/226bc671c73643887b36b8467b34ad485c2df062
-    ${python.pythonForBuild.interpreter} selftest.py
+    ${python.pythonOnBuildForHost.interpreter} selftest.py
   '';
 
   meta = with lib; {

pkgs/development/python-modules/nose3/default.nix

···
   doCheck = !isPyPy && !stdenv.isDarwin && !isPy311;
 
   checkPhase = ''
-    ${python.pythonForBuild.interpreter} selftest.py
+    ${python.pythonOnBuildForHost.interpreter} selftest.py
   '';
 
   meta = with lib; {

pkgs/development/python-modules/pyatspi/default.nix

···
   ];
 
   configureFlags = [
-    "PYTHON=${python.pythonForBuild.interpreter}"
+    "PYTHON=${python.pythonOnBuildForHost.interpreter}"
   ];
 
   postPatch = ''

pkgs/development/python-modules/pybind11/default.nix

···
     name = "pybind11-setup-hook";
     substitutions = {
       out = placeholder "out";
-      pythonInterpreter = python.pythonForBuild.interpreter;
+      pythonInterpreter = python.pythonOnBuildForHost.interpreter;
       pythonIncludeDir = "${python}/include/python${python.pythonVersion}";
       pythonSitePackages = "${python}/${python.sitePackages}";
     };

pkgs/development/python-modules/pycairo/default.nix

···
     # This is only used for figuring out what version of Python is in
     # use, and related stuff like figuring out what the install prefix
     # should be, but it does need to be able to execute Python code.
-    "-Dpython=${python.pythonForBuild.interpreter}"
+    "-Dpython=${python.pythonOnBuildForHost.interpreter}"
   ];
 
   meta = with lib; {

pkgs/development/python-modules/pycuda/default.nix

···
   };
 
   preConfigure = with lib.versions; ''
-    ${python.pythonForBuild.interpreter} configure.py --boost-inc-dir=${boost.dev}/include \
+    ${python.pythonOnBuildForHost.interpreter} configure.py --boost-inc-dir=${boost.dev}/include \
                           --boost-lib-dir=${boost}/lib \
                           --no-use-shipped-boost \
                           --boost-python-libname=boost_python${major python.version}${minor python.version} \

pkgs/development/python-modules/pyfuse3/default.nix

···
   propagatedBuildInputs = [ trio ];
 
   preBuild = ''
-    ${python.pythonForBuild.interpreter} setup.py build_cython
+    ${python.pythonOnBuildForHost.interpreter} setup.py build_cython
   '';
 
   nativeCheckInputs = [

pkgs/development/python-modules/pygame/default.nix

···
   ];
 
   preConfigure = ''
-    ${python.pythonForBuild.interpreter} buildconfig/config.py
+    ${python.pythonOnBuildForHost.interpreter} buildconfig/config.py
   '';
 
   checkPhase = ''

pkgs/development/python-modules/pygeos/default.nix

···
   # for the package to function. Therefore override of buildPhase was
   # necessary.
   buildPhase = ''
-    ${python.pythonForBuild.interpreter} setup.py build_ext --inplace
-    ${python.pythonForBuild.interpreter} setup.py bdist_wheel
+    ${python.pythonOnBuildForHost.interpreter} setup.py build_ext --inplace
+    ${python.pythonOnBuildForHost.interpreter} setup.py bdist_wheel
   '';
 
   nativeCheckInputs = [

pkgs/development/python-modules/pygobject/3.nix

···
     # This is only used for figuring out what version of Python is in
     # use, and related stuff like figuring out what the install prefix
     # should be, but it does need to be able to execute Python code.
-    "-Dpython=${python.pythonForBuild.interpreter}"
+    "-Dpython=${python.pythonOnBuildForHost.interpreter}"
   ];
 
   passthru = {

pkgs/development/python-modules/pymunk/default.nix

···
   ];
 
   preBuild = ''
-    ${python.pythonForBuild.interpreter} setup.py build_ext --inplace
+    ${python.pythonOnBuildForHost.interpreter} setup.py build_ext --inplace
   '';
 
   nativeCheckInputs = [

pkgs/development/python-modules/pyside2/default.nix

···
 
   postInstall = ''
     cd ../../..
-    ${python.pythonForBuild.interpreter} setup.py egg_info --build-type=pyside2
+    ${python.pythonOnBuildForHost.interpreter} setup.py egg_info --build-type=pyside2
     cp -r PySide2.egg-info $out/${python.sitePackages}/
   '';
 

pkgs/development/python-modules/pyside6/default.nix

···
 
   postInstall = ''
     cd ../../..
-    ${python.pythonForBuild.interpreter} setup.py egg_info --build-type=pyside6
+    ${python.pythonOnBuildForHost.interpreter} setup.py egg_info --build-type=pyside6
     cp -r PySide6.egg-info $out/${python.sitePackages}/
   '';
 

pkgs/development/python-modules/pysvn/default.nix

···
 
   preConfigure = ''
     cd Source
-    ${python.pythonForBuild.interpreter} setup.py backport
-    ${python.pythonForBuild.interpreter} setup.py configure \
+    ${python.pythonOnBuildForHost.interpreter} setup.py backport
+    ${python.pythonOnBuildForHost.interpreter} setup.py configure \
       --apr-inc-dir=${apr.dev}/include \
       --apu-inc-dir=${aprutil.dev}/include \
       --pycxx-dir=${pycxx.dev}/include \

pkgs/development/python-modules/python-efl/default.nix

···
   '';
 
   preBuild = ''
-    ${python.pythonForBuild.interpreter} setup.py build_ext
+    ${python.pythonOnBuildForHost.interpreter} setup.py build_ext
   '';
 
   installPhase = ''
-    ${python.pythonForBuild.interpreter} setup.py install --prefix=$out --single-version-externally-managed
+    ${python.pythonOnBuildForHost.interpreter} setup.py install --prefix=$out --single-version-externally-managed
   '';
 
   doCheck = false;

pkgs/development/python-modules/python-fontconfig/default.nix

···
   nativeBuildInputs = [ cython ];
 
   preBuild = ''
-    ${python.pythonForBuild.interpreter} setup.py build_ext -i
+    ${python.pythonOnBuildForHost.interpreter} setup.py build_ext -i
   '';
 
   checkPhase = ''

pkgs/development/python-modules/pywayland/default.nix

···
   nativeCheckInputs = [ pytestCheckHook ];
 
   postBuild = ''
-    ${python.pythonForBuild.interpreter} pywayland/ffi_build.py
+    ${python.pythonOnBuildForHost.interpreter} pywayland/ffi_build.py
   '';
 
   # Tests need this to create sockets

pkgs/development/python-modules/pywlroots/default.nix

···
   nativeCheckInputs = [ pytestCheckHook ];
 
   postBuild = ''
-    ${python.pythonForBuild.interpreter} wlroots/ffi_build.py
+    ${python.pythonOnBuildForHost.interpreter} wlroots/ffi_build.py
   '';
 
   pythonImportsCheck = [ "wlroots" ];

pkgs/development/python-modules/recursive-pth-loader/default.nix

···
 
   patchPhase = "cat ${./sitecustomize.py} > sitecustomize.py";
 
-  buildPhase = "${python.pythonForBuild}/bin/${python.pythonForBuild.executable} -m compileall .";
+  buildPhase = "${python.pythonOnBuildForHost}/bin/${python.pythonOnBuildForHost.executable} -m compileall .";
 
   installPhase =
     ''

pkgs/development/python-modules/redis-om/default.nix

···
   ];
 
   preBuild = ''
-    ${python.pythonForBuild.interpreter} make_sync.py
+    ${python.pythonOnBuildForHost.interpreter} make_sync.py
   '';
 
   nativeCheckInputs = [

pkgs/development/python-modules/shiboken2/default.nix

···
 
   postInstall = ''
     cd ../../..
-    ${python.pythonForBuild.interpreter} setup.py egg_info --build-type=shiboken2
+    ${python.pythonOnBuildForHost.interpreter} setup.py egg_info --build-type=shiboken2
     cp -r shiboken2.egg-info $out/${python.sitePackages}/
     rm $out/bin/shiboken_tool.py
   '';

pkgs/development/python-modules/shiboken6/default.nix

···
 
   postInstall = ''
     cd ../../..
-    ${python.pythonForBuild.interpreter} setup.py egg_info --build-type=shiboken6
+    ${python.pythonOnBuildForHost.interpreter} setup.py egg_info --build-type=shiboken6
     cp -r shiboken6.egg-info $out/${python.sitePackages}/
   '';
 

pkgs/development/python-modules/torch/default.nix

···
 
   preBuild = ''
     export MAX_JOBS=$NIX_BUILD_CORES
-    ${python.pythonForBuild.interpreter} setup.py build --cmake-only
+    ${python.pythonOnBuildForHost.interpreter} setup.py build --cmake-only
     ${cmake}/bin/cmake build
   '';
 

pkgs/development/python-modules/wxPython/4.2.nix

···
     export PATH="${wxGTK}/bin:$PATH"
     export SDL_CONFIG="${SDL.dev}/bin/sdl-config"
 
-    ${python.pythonForBuild.interpreter} build.py -v --use_syswx dox etg sip --nodoc build_py
+    ${python.pythonOnBuildForHost.interpreter} build.py -v --use_syswx dox etg sip --nodoc build_py
 
     runHook postBuild
   '';
···
   installPhase = ''
     runHook preInstall
 
-    ${python.pythonForBuild.interpreter} setup.py install --skip-build --prefix=$out
+    ${python.pythonOnBuildForHost.interpreter} setup.py install --skip-build --prefix=$out
     wrapPythonPrograms
 
     runHook postInstall

pkgs/development/python-modules/xattr/default.nix

···
   doCheck = false;
 
   postBuild = ''
-    ${python.pythonForBuild.interpreter} -m compileall -f xattr
+    ${python.pythonOnBuildForHost.interpreter} -m compileall -f xattr
   '';
 
   pythonImportsCheck = [

pkgs/development/python-modules/xkbcommon/default.nix

···
   nativeCheckInputs = [ pytestCheckHook ];
 
   postBuild = ''
-    ${python.pythonForBuild.interpreter} xkbcommon/ffi_build.py
+    ${python.pythonOnBuildForHost.interpreter} xkbcommon/ffi_build.py
   '';
 
   pythonImportsCheck = [ "xkbcommon" ];

pkgs/development/python2-modules/bootstrapped-pip/default.nix

···
 
     echo "Building setuptools wheel..."
     pushd setuptools
-    ${python.pythonForBuild.interpreter} -m pip install --no-build-isolation --no-index --prefix=$out  --ignore-installed --no-dependencies --no-cache .
+    ${python.pythonOnBuildForHost.interpreter} -m pip install --no-build-isolation --no-index --prefix=$out  --ignore-installed --no-dependencies --no-cache .
     popd
 
     echo "Building wheel wheel..."
     pushd wheel
-    ${python.pythonForBuild.interpreter} -m pip install --no-build-isolation --no-index --prefix=$out  --ignore-installed --no-dependencies --no-cache .
+    ${python.pythonOnBuildForHost.interpreter} -m pip install --no-build-isolation --no-index --prefix=$out  --ignore-installed --no-dependencies --no-cache .
     popd
 
     echo "Building pip wheel..."
     pushd pip
-    ${python.pythonForBuild.interpreter} -m pip install --no-build-isolation --no-index --prefix=$out  --ignore-installed --no-dependencies --no-cache .
+    ${python.pythonOnBuildForHost.interpreter} -m pip install --no-build-isolation --no-index --prefix=$out  --ignore-installed --no-dependencies --no-cache .
     popd
   '';
 

pkgs/development/python2-modules/pycairo/default.nix

···
     # This is only used for figuring out what version of Python is in
     # use, and related stuff like figuring out what the install prefix
     # should be, but it does need to be able to execute Python code.
-    "-Dpython=${python.pythonForBuild.interpreter}"
+    "-Dpython=${python.pythonOnBuildForHost.interpreter}"
   ];
 
   meta = with lib; {

pkgs/development/python2-modules/setuptools/default.nix

···
     ];
 
     buildPhase = ''
-      ${python.pythonForBuild.interpreter} bootstrap.py
-      ${python.pythonForBuild.interpreter} setup.py sdist --formats=gztar
+      ${python.pythonOnBuildForHost.interpreter} bootstrap.py
+      ${python.pythonOnBuildForHost.interpreter} setup.py sdist --formats=gztar
 
       # Here we untar the sdist and retar it in order to control the timestamps
       # of all the files included

pkgs/development/tools/fdroidserver/default.nix

···
   '';
 
   preConfigure = ''
-    ${python3.pythonForBuild.interpreter} setup.py compile_catalog
+    ${python3.pythonOnBuildForHost.interpreter} setup.py compile_catalog
   '';
 
   postInstall = ''

pkgs/development/tools/misc/ycmd/default.nix

···
 
   buildPhase = ''
     export EXTRA_CMAKE_ARGS="-DPATH_TO_LLVM_ROOT=${llvmPackages.libllvm} -DUSE_SYSTEM_ABSEIL=true"
-    ${python.pythonForBuild.interpreter} build.py --system-libclang --clang-completer --ninja
+    ${python.pythonOnBuildForHost.interpreter} build.py --system-libclang --clang-completer --ninja
   '';
 
   dontConfigure = true;

pkgs/os-specific/linux/bolt/default.nix

···
     dbus
     gobject-introspection
     umockdev
-    (python3.pythonForBuild.withPackages
+    (python3.pythonOnBuildForHost.withPackages
       (p: [ p.pygobject3 p.dbus-python p.python-dbusmock ]))
   ];
 

pkgs/os-specific/linux/libnl/default.nix

···
 
   postBuild = lib.optionalString (pythonSupport) ''
       cd python
-      ${python.pythonForBuild.interpreter} setup.py install --prefix=../pythonlib
+      ${python.pythonOnBuildForHost.interpreter} setup.py install --prefix=../pythonlib
       cd -
   '';
 

pkgs/os-specific/linux/libnvme/default.nix

···
     ninja
     perl # for kernel-doc
     pkg-config
-    python3.pythonForBuild
+    python3.pythonOnBuildForHost
     swig
   ];
 

pkgs/os-specific/linux/libselinux/default.nix

···
   ] ++ optionals stdenv.hostPlatform.isStatic [
     "DISABLE_SHARED=y"
   ] ++ optionals enablePython [
-    "PYTHON=${python3.pythonForBuild.interpreter}"
+    "PYTHON=${python3.pythonOnBuildForHost.interpreter}"
     "PYTHONLIBDIR=$(py)/${python3.sitePackages}"
   ];
 

pkgs/os-specific/linux/power-profiles-daemon/default.nix

···
     wrapGAppsNoGuiHook
     python3.pkgs.wrapPython
     # checkInput but cheked for during the configuring
-    (python3.pythonForBuild.withPackages (ps: with ps; [
+    (python3.pythonOnBuildForHost.withPackages (ps: with ps; [
       pygobject3
       dbus-python
       python-dbusmock

pkgs/servers/home-assistant/intents.nix

···
   postInstall = ''
     pushd intents
     # https://github.com/home-assistant/intents/blob/main/script/package#L18
-    ${python.pythonForBuild.interpreter} -m script.intentfest merged_output $out/${python.sitePackages}/home_assistant_intents/data
+    ${python.pythonOnBuildForHost.interpreter} -m script.intentfest merged_output $out/${python.sitePackages}/home_assistant_intents/data
     popd
   '';
 

pkgs/servers/uwsgi/default.nix

···
   };
 
   pythonPlugin = pkg : lib.nameValuePair "python${if pkg.isPy2 then "2" else "3"}" {
-    interpreter = pkg.pythonForBuild.interpreter;
+    interpreter = pkg.pythonOnBuildForHost.interpreter;
     path = "plugins/python";
     inputs = [ pkg ncurses ];
     install = ''
       install -Dm644 uwsgidecorators.py $out/${pkg.sitePackages}/uwsgidecorators.py
-      ${pkg.pythonForBuild.executable} -m compileall $out/${pkg.sitePackages}/
-      ${pkg.pythonForBuild.executable} -O -m compileall $out/${pkg.sitePackages}/
+      ${pkg.pythonOnBuildForHost.executable} -m compileall $out/${pkg.sitePackages}/
+      ${pkg.pythonOnBuildForHost.executable} -O -m compileall $out/${pkg.sitePackages}/
     '';
   };
 

pkgs/tools/audio/tts/default.nix

···
     # cython modules are not installed for some reasons
     (
       cd TTS/tts/utils/monotonic_align
-      ${python.pythonForBuild.interpreter} setup.py install --prefix=$out
+      ${python.pythonOnBuildForHost.interpreter} setup.py install --prefix=$out
     )
   '';
 

pkgs/tools/backup/s3ql/default.nix

···
   ];
 
   preBuild = ''
-    ${python3Packages.python.pythonForBuild.interpreter} ./setup.py build_cython build_ext --inplace
+    ${python3Packages.python.pythonOnBuildForHost.interpreter} ./setup.py build_cython build_ext --inplace
   '';
 
   checkPhase = ''

pkgs/tools/networking/networkmanager/default.nix

···
 }:
 
 let
-  pythonForDocs = python3.pythonForBuild.withPackages (pkgs: with pkgs; [ pygobject3 ]);
+  pythonForDocs = python3.pythonOnBuildForHost.withPackages (pkgs: with pkgs; [ pygobject3 ]);
 in
 stdenv.mkDerivation rec {
   pname = "networkmanager";

pkgs/tools/security/fail2ban/default.nix

···
     substituteInPlace setup.py --replace /usr/share/doc/ share/doc/
 
     # see https://github.com/NixOS/nixpkgs/issues/4968
-    ${python3.pythonForBuild.interpreter} setup.py install_data --install-dir=$out --root=$out
+    ${python3.pythonOnBuildForHost.interpreter} setup.py install_data --install-dir=$out --root=$out
   '';
 
   postInstall =

pkgs/tools/system/minijail/tools.nix

···
     make libconstants.gen.c libsyscalls.gen.c
     ${targetClang}/bin/${targetClang.targetPrefix}cc -S -emit-llvm \
         libconstants.gen.c libsyscalls.gen.c
-    ${python.pythonForBuild.interpreter} tools/generate_constants_json.py \
+    ${python.pythonOnBuildForHost.interpreter} tools/generate_constants_json.py \
         --output constants.json \
         libconstants.gen.ll libsyscalls.gen.ll
   '';