426 lines
12 KiB
Nix
426 lines
12 KiB
Nix
# Generic builder.
|
|
|
|
{
|
|
lib,
|
|
config,
|
|
python,
|
|
wrapPython,
|
|
unzip,
|
|
ensureNewerSourcesForZipFilesHook,
|
|
# Whether the derivation provides a Python module or not.
|
|
toPythonModule,
|
|
namePrefix,
|
|
update-python-libraries,
|
|
setuptools,
|
|
pypaBuildHook,
|
|
pypaInstallHook,
|
|
pythonCatchConflictsHook,
|
|
pythonImportsCheckHook,
|
|
pythonNamespacesHook,
|
|
pythonOutputDistHook,
|
|
pythonRemoveBinBytecodeHook,
|
|
pythonRemoveTestsDirHook,
|
|
pythonRuntimeDepsCheckHook,
|
|
setuptoolsBuildHook,
|
|
setuptoolsCheckHook,
|
|
wheelUnpackHook,
|
|
eggUnpackHook,
|
|
eggBuildHook,
|
|
eggInstallHook,
|
|
}:
|
|
|
|
let
|
|
inherit (builtins) unsafeGetAttrPos;
|
|
inherit (lib)
|
|
elem
|
|
optionalString
|
|
max
|
|
stringLength
|
|
fixedWidthString
|
|
getName
|
|
optional
|
|
optionals
|
|
optionalAttrs
|
|
hasSuffix
|
|
escapeShellArgs
|
|
extendDerivation
|
|
head
|
|
splitString
|
|
isBool
|
|
;
|
|
|
|
leftPadName =
|
|
name: against:
|
|
let
|
|
len = max (stringLength name) (stringLength against);
|
|
in
|
|
fixedWidthString len " " name;
|
|
|
|
isPythonModule =
|
|
drv:
|
|
# all pythonModules have the pythonModule attribute
|
|
(drv ? "pythonModule")
|
|
# Some pythonModules are turned in to a pythonApplication by setting the field to false
|
|
&& (!isBool drv.pythonModule);
|
|
|
|
isMismatchedPython = drv: drv.pythonModule != python;
|
|
|
|
withDistOutput' = lib.flip elem [
|
|
"pyproject"
|
|
"setuptools"
|
|
"wheel"
|
|
];
|
|
|
|
isBootstrapInstallPackage' = lib.flip elem [
|
|
"flit-core"
|
|
"installer"
|
|
];
|
|
|
|
isBootstrapPackage' = lib.flip elem (
|
|
[
|
|
"build"
|
|
"packaging"
|
|
"pyproject-hooks"
|
|
"wheel"
|
|
]
|
|
++ optionals (python.pythonOlder "3.11") [ "tomli" ]
|
|
);
|
|
|
|
isSetuptoolsDependency' = lib.flip elem [
|
|
"setuptools"
|
|
"wheel"
|
|
];
|
|
|
|
cleanAttrs = lib.flip removeAttrs [
|
|
"disabled"
|
|
"checkPhase"
|
|
"checkInputs"
|
|
"nativeCheckInputs"
|
|
"doCheck"
|
|
"doInstallCheck"
|
|
"dontWrapPythonPrograms"
|
|
"catchConflicts"
|
|
"pyproject"
|
|
"format"
|
|
"disabledTestPaths"
|
|
"outputs"
|
|
"stdenv"
|
|
"dependencies"
|
|
"optional-dependencies"
|
|
"build-system"
|
|
];
|
|
|
|
in
|
|
|
|
{
|
|
name ? "${attrs.pname}-${attrs.version}",
|
|
|
|
# Build-time dependencies for the package
|
|
nativeBuildInputs ? [ ],
|
|
|
|
# Run-time dependencies for the package
|
|
buildInputs ? [ ],
|
|
|
|
# Dependencies needed for running the checkPhase.
|
|
# These are added to buildInputs when doCheck = true.
|
|
checkInputs ? [ ],
|
|
nativeCheckInputs ? [ ],
|
|
|
|
# propagate build dependencies so in case we have A -> B -> C,
|
|
# C can import package A propagated by B
|
|
propagatedBuildInputs ? [ ],
|
|
|
|
# Python module dependencies.
|
|
# These are named after PEP-621.
|
|
dependencies ? [ ],
|
|
optional-dependencies ? { },
|
|
|
|
# Python PEP-517 build systems.
|
|
build-system ? [ ],
|
|
|
|
# DEPRECATED: use propagatedBuildInputs
|
|
pythonPath ? [ ],
|
|
|
|
# Enabled to detect some (native)BuildInputs mistakes
|
|
strictDeps ? true,
|
|
|
|
outputs ? [ "out" ],
|
|
|
|
# used to disable derivation, useful for specific python versions
|
|
disabled ? false,
|
|
|
|
# Raise an error if two packages are installed with the same name
|
|
# TODO: For cross we probably need a different PYTHONPATH, or not
|
|
# add the runtime deps until after buildPhase.
|
|
catchConflicts ? (python.stdenv.hostPlatform == python.stdenv.buildPlatform),
|
|
|
|
# Additional arguments to pass to the makeWrapper function, which wraps
|
|
# generated binaries.
|
|
makeWrapperArgs ? [ ],
|
|
|
|
# Skip wrapping of python programs altogether
|
|
dontWrapPythonPrograms ? false,
|
|
|
|
# Don't use Pip to install a wheel
|
|
# Note this is actually a variable for the pipInstallPhase in pip's setupHook.
|
|
# It's included here to prevent an infinite recursion.
|
|
dontUsePipInstall ? false,
|
|
|
|
# Skip setting the PYTHONNOUSERSITE environment variable in wrapped programs
|
|
permitUserSite ? false,
|
|
|
|
# Remove bytecode from bin folder.
|
|
# When a Python script has the extension `.py`, bytecode is generated
|
|
# Typically, executables in bin have no extension, so no bytecode is generated.
|
|
# However, some packages do provide executables with extensions, and thus bytecode is generated.
|
|
removeBinBytecode ? true,
|
|
|
|
# pyproject = true <-> format = "pyproject"
|
|
# pyproject = false <-> format = "other"
|
|
# https://github.com/NixOS/nixpkgs/issues/253154
|
|
pyproject ? null,
|
|
|
|
# Several package formats are supported.
|
|
# "setuptools" : Install a common setuptools/distutils based package. This builds a wheel.
|
|
# "wheel" : Install from a pre-compiled wheel.
|
|
# "pyproject": Install a package using a ``pyproject.toml`` file (PEP517). This builds a wheel.
|
|
# "egg": Install a package from an egg.
|
|
# "other" : Provide your own buildPhase and installPhase.
|
|
format ? null,
|
|
|
|
meta ? { },
|
|
|
|
doCheck ? config.doCheckByDefault or false,
|
|
|
|
disabledTestPaths ? [ ],
|
|
|
|
# Allow passing in a custom stdenv to buildPython*
|
|
stdenv ? python.stdenv,
|
|
|
|
...
|
|
}@attrs:
|
|
|
|
assert (pyproject != null) -> (format == null);
|
|
|
|
let
|
|
format' =
|
|
if pyproject != null then
|
|
if pyproject then "pyproject" else "other"
|
|
else if format != null then
|
|
format
|
|
else
|
|
"setuptools";
|
|
|
|
withDistOutput = withDistOutput' format';
|
|
|
|
validatePythonMatches =
|
|
let
|
|
throwMismatch =
|
|
attrName: drv:
|
|
let
|
|
myName = "'${namePrefix}${name}'";
|
|
theirName = "'${drv.name}'";
|
|
optionalLocation =
|
|
let
|
|
pos = unsafeGetAttrPos (if attrs ? "pname" then "pname" else "name") attrs;
|
|
in
|
|
optionalString (pos != null) " at ${pos.file}:${toString pos.line}:${toString pos.column}";
|
|
in
|
|
throw ''
|
|
Python version mismatch in ${myName}:
|
|
|
|
The Python derivation ${myName} depends on a Python derivation
|
|
named ${theirName}, but the two derivations use different versions
|
|
of Python:
|
|
|
|
${leftPadName myName theirName} uses ${python}
|
|
${leftPadName theirName myName} uses ${toString drv.pythonModule}
|
|
|
|
Possible solutions:
|
|
|
|
* If ${theirName} is a Python library, change the reference to ${theirName}
|
|
in the ${attrName} of ${myName} to use a ${theirName} built from the same
|
|
version of Python
|
|
|
|
* If ${theirName} is used as a tool during the build, move the reference to
|
|
${theirName} in ${myName} from ${attrName} to nativeBuildInputs
|
|
|
|
* If ${theirName} provides executables that are called at run time, pass its
|
|
bin path to makeWrapperArgs:
|
|
|
|
makeWrapperArgs = [ "--prefix PATH : ''${lib.makeBinPath [ ${getName drv} ] }" ];
|
|
|
|
${optionalLocation}
|
|
'';
|
|
|
|
checkDrv =
|
|
attrName: drv:
|
|
if (isPythonModule drv) && (isMismatchedPython drv) then throwMismatch attrName drv else drv;
|
|
|
|
in
|
|
attrName: inputs: map (checkDrv attrName) inputs;
|
|
|
|
isBootstrapInstallPackage = isBootstrapInstallPackage' (attrs.pname or null);
|
|
|
|
isBootstrapPackage = isBootstrapInstallPackage || isBootstrapPackage' (attrs.pname or null);
|
|
|
|
isSetuptoolsDependency = isSetuptoolsDependency' (attrs.pname or null);
|
|
|
|
passthru =
|
|
attrs.passthru or { }
|
|
// {
|
|
updateScript =
|
|
let
|
|
filename = head (splitString ":" self.meta.position);
|
|
in
|
|
attrs.passthru.updateScript or [
|
|
update-python-libraries
|
|
filename
|
|
];
|
|
}
|
|
// optionalAttrs (dependencies != [ ]) { inherit dependencies; }
|
|
// optionalAttrs (optional-dependencies != { }) { inherit optional-dependencies; }
|
|
// optionalAttrs (build-system != [ ]) { inherit build-system; };
|
|
|
|
# Keep extra attributes from `attrs`, e.g., `patchPhase', etc.
|
|
self = toPythonModule (
|
|
stdenv.mkDerivation (
|
|
(cleanAttrs attrs)
|
|
// {
|
|
|
|
name = namePrefix + name;
|
|
|
|
nativeBuildInputs =
|
|
[
|
|
python
|
|
wrapPython
|
|
ensureNewerSourcesForZipFilesHook # move to wheel installer (pip) or builder (setuptools, flit, ...)?
|
|
pythonRemoveTestsDirHook
|
|
]
|
|
++ optionals (catchConflicts && !isBootstrapPackage && !isSetuptoolsDependency) [
|
|
#
|
|
# 1. When building a package that is also part of the bootstrap chain, we
|
|
# must ignore conflicts after installation, because there will be one with
|
|
# the package in the bootstrap.
|
|
#
|
|
# 2. When a package is a dependency of setuptools, we must ignore conflicts
|
|
# because the hook that checks for conflicts uses setuptools.
|
|
#
|
|
pythonCatchConflictsHook
|
|
]
|
|
++ optionals removeBinBytecode [ pythonRemoveBinBytecodeHook ]
|
|
++ optionals (hasSuffix "zip" (attrs.src.name or "")) [ unzip ]
|
|
++ optionals (format' == "setuptools") [ setuptoolsBuildHook ]
|
|
++ optionals (format' == "pyproject") [
|
|
(
|
|
if isBootstrapPackage then
|
|
pypaBuildHook.override {
|
|
inherit (python.pythonOnBuildForHost.pkgs.bootstrap) build;
|
|
wheel = null;
|
|
}
|
|
else
|
|
pypaBuildHook
|
|
)
|
|
(
|
|
if isBootstrapPackage then
|
|
pythonRuntimeDepsCheckHook.override {
|
|
inherit (python.pythonOnBuildForHost.pkgs.bootstrap) packaging;
|
|
}
|
|
else
|
|
pythonRuntimeDepsCheckHook
|
|
)
|
|
]
|
|
++ optionals (format' == "wheel") [ wheelUnpackHook ]
|
|
++ optionals (format' == "egg") [
|
|
eggUnpackHook
|
|
eggBuildHook
|
|
eggInstallHook
|
|
]
|
|
++ optionals (format' != "other") [
|
|
(
|
|
if isBootstrapInstallPackage then
|
|
pypaInstallHook.override { inherit (python.pythonOnBuildForHost.pkgs.bootstrap) installer; }
|
|
else
|
|
pypaInstallHook
|
|
)
|
|
]
|
|
++ optionals (stdenv.buildPlatform == stdenv.hostPlatform) [
|
|
# This is a test, however, it should be ran independent of the checkPhase and checkInputs
|
|
pythonImportsCheckHook
|
|
]
|
|
++ optionals (python.pythonAtLeast "3.3") [
|
|
# Optionally enforce PEP420 for python3
|
|
pythonNamespacesHook
|
|
]
|
|
++ optionals withDistOutput [ pythonOutputDistHook ]
|
|
++ nativeBuildInputs
|
|
++ build-system;
|
|
|
|
buildInputs = validatePythonMatches "buildInputs" (buildInputs ++ pythonPath);
|
|
|
|
propagatedBuildInputs = validatePythonMatches "propagatedBuildInputs" (
|
|
propagatedBuildInputs
|
|
++ dependencies
|
|
++ [
|
|
# we propagate python even for packages transformed with 'toPythonApplication'
|
|
# this pollutes the PATH but avoids rebuilds
|
|
# see https://github.com/NixOS/nixpkgs/issues/170887 for more context
|
|
python
|
|
]
|
|
);
|
|
|
|
inherit strictDeps;
|
|
|
|
LANG = "${if python.stdenv.isDarwin then "en_US" else "C"}.UTF-8";
|
|
|
|
# Python packages don't have a checkPhase, only an installCheckPhase
|
|
doCheck = false;
|
|
doInstallCheck = attrs.doCheck or true;
|
|
nativeInstallCheckInputs =
|
|
[ ]
|
|
++ optionals (format' == "setuptools") [
|
|
# Longer-term we should get rid of this and require
|
|
# users of this function to set the `installCheckPhase` or
|
|
# pass in a hook that sets it.
|
|
setuptoolsCheckHook
|
|
]
|
|
++ nativeCheckInputs;
|
|
installCheckInputs = checkInputs;
|
|
|
|
postFixup =
|
|
optionalString (!dontWrapPythonPrograms) ''
|
|
wrapPythonPrograms
|
|
''
|
|
+ attrs.postFixup or "";
|
|
|
|
# Python packages built through cross-compilation are always for the host platform.
|
|
disallowedReferences = optionals (python.stdenv.hostPlatform != python.stdenv.buildPlatform) [
|
|
python.pythonOnBuildForHost
|
|
];
|
|
|
|
outputs = outputs ++ optional withDistOutput "dist";
|
|
|
|
inherit passthru;
|
|
|
|
meta = {
|
|
# default to python's platforms
|
|
platforms = python.meta.platforms;
|
|
isBuildPythonPackage = python.meta.platforms;
|
|
} // meta;
|
|
}
|
|
// optionalAttrs (attrs ? checkPhase) {
|
|
# If given use the specified checkPhase, otherwise use the setup hook.
|
|
# Longer-term we should get rid of `checkPhase` and use `installCheckPhase`.
|
|
installCheckPhase = attrs.checkPhase;
|
|
}
|
|
// optionalAttrs (disabledTestPaths != [ ]) {
|
|
disabledTestPaths = escapeShellArgs disabledTestPaths;
|
|
}
|
|
)
|
|
);
|
|
|
|
in
|
|
extendDerivation (
|
|
disabled -> throw "${name} not supported for interpreter ${python.executable}"
|
|
) passthru self
|