hiro/poetry2nix
1
0
Fork 0
mirror of https://github.com/vale981/poetry2nix synced 2025-03-04 16:51:40 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions

nixpkgs-fmt: format all the nix code

Browse source
This commit is contained in:
zimbatm 2019-12-11 13:31:22 +01:00
parent 4c024740b2
commit 310282154c
No known key found for this signature in database
GPG key ID: 71BAF6D40C1D63D7
8 changed files with 635 additions and 495 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

309
default.nix
View file

@ -1,9 +1,7 @@
{ { pkgs ? import <nixpkgs> {}
pkgs ? import <nixpkgs> { }, , lib ? pkgs.lib
lib ? pkgs.lib, , poetry ? null
poetry ? null,
}: }:
let let
importTOML = path: builtins.fromTOML (builtins.readFile path); importTOML = path: builtins.fromTOML (builtins.readFile path);
@ -24,39 +22,47 @@ let
# file: filename including extension # file: filename including extension
# hash: SRI hash # hash: SRI hash
# kind: Language implementation and version tag https://www.python.org/dev/peps/pep-0427/#file-name-convention # kind: Language implementation and version tag https://www.python.org/dev/peps/pep-0427/#file-name-convention
fetchFromPypi = lib.makeOverridable ({ pname, file, hash, kind }: fetchFromPypi = lib.makeOverridable (
pkgs.fetchurl { { pname, file, hash, kind }:
url = "https://files.pythonhosted.org/packages/${kind}/${lib.toLower (builtins.substring 0 1 file)}/${pname}/${file}"; pkgs.fetchurl {
inherit hash; url = "https://files.pythonhosted.org/packages/${kind}/${lib.toLower (builtins.substring 0 1 file)}/${pname}/${file}";
}); inherit hash;
}
);
getAttrPath = attrPath: set: ( getAttrPath = attrPath: set: (
builtins.foldl' builtins.foldl'
(acc: v: if builtins.typeOf acc == "set" && builtins.hasAttr v acc then acc."${v}" else null) (acc: v: if builtins.typeOf acc == "set" && builtins.hasAttr v acc then acc."${v}" else null)
set (lib.splitString "." attrPath) set (lib.splitString "." attrPath)
); );
satisfiesSemver = (import ./semver.nix {inherit lib;}).satisfies; satisfiesSemver = (import ./semver.nix { inherit lib; }).satisfies;
# Check Python version is compatible with package # Check Python version is compatible with package
isCompatible = pythonVersion: pythonVersions: let isCompatible = pythonVersion: pythonVersions: let
operators = { operators = {
"||" = cond1: cond2: cond1 || cond2; "||" = cond1: cond2: cond1 || cond2;
"," = cond1: cond2: cond1 && cond2; # , means && "," = cond1: cond2: cond1 && cond2; # , means &&
}; };
tokens = builtins.filter (x: x != "") (builtins.split "(,|\\|\\|)" pythonVersions); tokens = builtins.filter (x: x != "") (builtins.split "(,|\\|\\|)" pythonVersions);
in (builtins.foldl' (acc: v: let in
isOperator = builtins.typeOf v == "list"; (
operator = if isOperator then (builtins.elemAt v 0) else acc.operator; builtins.foldl' (
in if isOperator then (acc // {inherit operator;}) else { acc: v: let
inherit operator; isOperator = builtins.typeOf v == "list";
state = operators."${operator}" acc.state (satisfiesSemver pythonVersion v); operator = if isOperator then (builtins.elemAt v 0) else acc.operator;
}) in
{ if isOperator then (acc // { inherit operator; }) else {
operator = ","; inherit operator;
state = true; state = operators."${operator}" acc.state (satisfiesSemver pythonVersion v);
} }
tokens).state; )
{
operator = ",";
state = true;
}
tokens
).state;
extensions = pkgs.lib.importJSON ./extensions.json; extensions = pkgs.lib.importJSON ./extensions.json;
getExtension = filename: builtins.elemAt getExtension = filename: builtins.elemAt
@ -75,139 +81,158 @@ let
stdenv = pkgs.stdenv; stdenv = pkgs.stdenv;
}; };
mkPoetryPackage = { mkPoetryPackage =
src, { src
pyproject ? src + "/pyproject.toml", , pyproject ? src + "/pyproject.toml"
poetrylock ? src + "/poetry.lock", , poetrylock ? src + "/poetry.lock"
overrides ? defaultPoetryOverrides, , overrides ? defaultPoetryOverrides
meta ? {}, , meta ? {}
python ? pkgs.python3, , python ? pkgs.python3
... , ...
}@attrs: let }@attrs: let
pyProject = importTOML pyproject; pyProject = importTOML pyproject;
poetryLock = importTOML poetrylock; poetryLock = importTOML poetrylock;
files = getAttrDefault "files" (getAttrDefault "metadata" poetryLock {}) {}; files = getAttrDefault "files" (getAttrDefault "metadata" poetryLock {}) {};
specialAttrs = [ "pyproject" "poetrylock" "overrides" ]; specialAttrs = [ "pyproject" "poetrylock" "overrides" ];
passedAttrs = builtins.removeAttrs attrs specialAttrs; passedAttrs = builtins.removeAttrs attrs specialAttrs;
evalPep508 = mkEvalPep508 python; evalPep508 = mkEvalPep508 python;
poetryPkg = poetry.override { inherit python; }; poetryPkg = poetry.override { inherit python; };
# Create an overriden version of pythonPackages # Create an overriden version of pythonPackages
# #
# We need to avoid mixing multiple versions of pythonPackages in the same # We need to avoid mixing multiple versions of pythonPackages in the same
# closure as python can only ever have one version of a dependency # closure as python can only ever have one version of a dependency
py = let py = let
packageOverrides = self: super: let packageOverrides = self: super: let
getDep = depName: if builtins.hasAttr depName self then self."${depName}" else null; getDep = depName: if builtins.hasAttr depName self then self."${depName}" else null;
mkPoetryDep = pkgMeta: let mkPoetryDep = pkgMeta: let
pkgFiles = let pkgFiles = let
all = getAttrDefault pkgMeta.name files []; all = getAttrDefault pkgMeta.name files [];
in builtins.filter (f: fileSupported f.file) all; in
builtins.filter (f: fileSupported f.file) all;
files_sdist = builtins.filter isSdist pkgFiles; files_sdist = builtins.filter isSdist pkgFiles;
files_bdist = builtins.filter isBdist pkgFiles; files_bdist = builtins.filter isBdist pkgFiles;
files_supported = files_sdist ++ files_bdist; files_supported = files_sdist ++ files_bdist;
# Only files matching this version # Only files matching this version
filterFile = fname: builtins.match ("^.*" + builtins.replaceStrings [ "." ] [ "\\." ] pkgMeta.version + ".*$") fname != null; filterFile = fname: builtins.match ("^.*" + builtins.replaceStrings [ "." ] [ "\\." ] pkgMeta.version + ".*$") fname != null;
files_filtered = builtins.filter (f: filterFile f.file) files_supported; files_filtered = builtins.filter (f: filterFile f.file) files_supported;
# Grab the first dist, we dont care about which one # Grab the first dist, we dont care about which one
file = assert builtins.length files_filtered >= 1; builtins.elemAt files_filtered 0; file = assert builtins.length files_filtered >= 1; builtins.elemAt files_filtered 0;
format = format =
if isBdist file if isBdist file
then "wheel" then "wheel"
else "setuptools"; else "setuptools";
in self.buildPythonPackage { in
pname = pkgMeta.name; self.buildPythonPackage {
version = pkgMeta.version; pname = pkgMeta.name;
version = pkgMeta.version;
doCheck = false; # We never get development deps doCheck = false; # We never get development deps
inherit format; inherit format;
propagatedBuildInputs = let propagatedBuildInputs = let
depAttrs = getAttrDefault "dependencies" pkgMeta {}; depAttrs = getAttrDefault "dependencies" pkgMeta {};
# Some dependencies like django gets the attribute name django # Some dependencies like django gets the attribute name django
# but dependencies try to access Django # but dependencies try to access Django
dependencies = builtins.map (d: lib.toLower d) (builtins.attrNames depAttrs); dependencies = builtins.map (d: lib.toLower d) (builtins.attrNames depAttrs);
in builtins.map getDep dependencies; in
builtins.map getDep dependencies;
meta = { meta = {
broken = ! isCompatible python.version pkgMeta.python-versions; broken = ! isCompatible python.version pkgMeta.python-versions;
license = []; license = [];
};
src = fetchFromPypi {
pname = pkgMeta.name;
inherit (file) file hash;
# We need to retrieve kind from the interpreter and the filename of the package
# Interpreters should declare what wheel types they're compatible with (python type + ABI)
# Here we can then choose a file based on that info.
kind = if format == "wheel" then "py2.py3" else "source";
};
};
# Filter packages by their PEP508 markers
pkgsWithFilter = builtins.map (
pkgMeta: let
f = if builtins.hasAttr "marker" pkgMeta then (!evalPep508 pkgMeta.marker) else false;
in
pkgMeta // { p2nixFiltered = f; }
) poetryLock.package;
lockPkgs = builtins.map (
pkgMeta: {
name = pkgMeta.name;
value = let
drv = mkPoetryDep pkgMeta;
override = getAttrDefault pkgMeta.name overrides (_: _: drv: drv);
in
if drv != null then (override self super drv) else null;
}
) (builtins.filter (pkgMeta: !pkgMeta.p2nixFiltered) pkgsWithFilter);
# Null out any filtered packages, we don't want python.pkgs from nixpkgs
nulledPkgs = (
builtins.listToAttrs
(
builtins.map (x: { name = x.name; value = null; })
(builtins.filter (pkgMeta: pkgMeta.p2nixFiltered) pkgsWithFilter)
)
);
in
nulledPkgs // builtins.listToAttrs lockPkgs;
in
python.override { inherit packageOverrides; self = py; };
pythonPackages = py.pkgs;
getDeps = depAttr: let
deps = getAttrDefault depAttr pyProject.tool.poetry {};
depAttrs = builtins.map (d: lib.toLower d) (builtins.attrNames deps);
in
builtins.map (dep: pythonPackages."${dep}") depAttrs;
getInputs = attr: getAttrDefault attr attrs [];
mkInput = attr: extraInputs: getInputs attr ++ extraInputs;
hasPoetryBuildSystem = getAttrPath "build-system.build-backend" pyProject == "poetry.masonry.api";
in
pythonPackages.buildPythonApplication (
passedAttrs // {
pname = pyProject.tool.poetry.name;
version = pyProject.tool.poetry.version;
format = "pyproject";
buildInputs = mkInput "buildInputs" (lib.optional hasPoetryBuildSystem poetryPkg);
propagatedBuildInputs = mkInput "propagatedBuildInputs" (getDeps "dependencies") ++ ([ pythonPackages.setuptools ]);
checkInputs = mkInput "checkInputs" (getDeps "dev-dependencies");
passthru = {
inherit pythonPackages;
}; };
src = fetchFromPypi { meta = meta // {
pname = pkgMeta.name; inherit (pyProject.tool.poetry) description;
inherit (file) file hash; licenses = [ pyProject.tool.poetry.license ];
# We need to retrieve kind from the interpreter and the filename of the package
# Interpreters should declare what wheel types they're compatible with (python type + ABI)
# Here we can then choose a file based on that info.
kind = if format == "wheel" then "py2.py3" else "source";
}; };
};
# Filter packages by their PEP508 markers }
pkgsWithFilter = builtins.map (pkgMeta: let );
f = if builtins.hasAttr "marker" pkgMeta then (!evalPep508 pkgMeta.marker) else false;
in pkgMeta // { p2nixFiltered = f; }) poetryLock.package;
lockPkgs = builtins.map (pkgMeta: { in
name = pkgMeta.name; {
value = let
drv = mkPoetryDep pkgMeta;
override = getAttrDefault pkgMeta.name overrides (_: _: drv: drv);
in if drv != null then (override self super drv) else null;
}) (builtins.filter (pkgMeta: !pkgMeta.p2nixFiltered) pkgsWithFilter);
# Null out any filtered packages, we don't want python.pkgs from nixpkgs
nulledPkgs = (
builtins.listToAttrs
(builtins.map (x: { name = x.name; value = null; })
(builtins.filter (pkgMeta: pkgMeta.p2nixFiltered) pkgsWithFilter)));
in nulledPkgs // builtins.listToAttrs lockPkgs;
in python.override { inherit packageOverrides; self = py; };
pythonPackages = py.pkgs;
getDeps = depAttr: let
deps = getAttrDefault depAttr pyProject.tool.poetry {};
depAttrs = builtins.map (d: lib.toLower d) (builtins.attrNames deps);
in builtins.map (dep: pythonPackages."${dep}") depAttrs;
getInputs = attr: getAttrDefault attr attrs [];
mkInput = attr: extraInputs: getInputs attr ++ extraInputs;
hasPoetryBuildSystem = getAttrPath "build-system.build-backend" pyProject == "poetry.masonry.api";
in pythonPackages.buildPythonApplication (passedAttrs // {
pname = pyProject.tool.poetry.name;
version = pyProject.tool.poetry.version;
format = "pyproject";
buildInputs = mkInput "buildInputs" (lib.optional hasPoetryBuildSystem poetryPkg);
propagatedBuildInputs = mkInput "propagatedBuildInputs" (getDeps "dependencies") ++ ([ pythonPackages.setuptools ]);
checkInputs = mkInput "checkInputs" (getDeps "dev-dependencies");
passthru = {
inherit pythonPackages;
};
meta = meta // {
inherit (pyProject.tool.poetry) description;
licenses = [ pyProject.tool.poetry.license ];
};
});
in {
inherit mkPoetryPackage defaultPoetryOverrides; inherit mkPoetryPackage defaultPoetryOverrides;
} }

28
flake.nix
View file

@ -8,21 +8,25 @@
systems = [ "x86_64-linux" "i686-linux" "x86_64-darwin" "aarch64-linux" ]; systems = [ "x86_64-linux" "i686-linux" "x86_64-darwin" "aarch64-linux" ];
forAllSystems = f: nixpkgs.lib.genAttrs systems (system: f system); forAllSystems = f: nixpkgs.lib.genAttrs systems (system: f system);
# Memoize nixpkgs for different platforms for efficiency. # Memoize nixpkgs for different platforms for efficiency.
nixpkgsFor = forAllSystems (system: nixpkgsFor = forAllSystems (
import nixpkgs { system:
inherit system; import nixpkgs {
overlays = [ self.overlay ]; inherit system;
} overlays = [ self.overlay ];
}
); );
in { in
{
overlay = import ./overlay.nix; overlay = import ./overlay.nix;
# TODO: I feel like `packages` is the wrong place for the poetry2nix attr # TODO: I feel like `packages` is the wrong place for the poetry2nix attr
packages = forAllSystems (system: { packages = forAllSystems (
inherit (nixpkgsFor.${system}) poetry poetry2nix; system: {
}); inherit (nixpkgsFor.${system}) poetry poetry2nix;
}
);
}; };
} }

537
overrides.nix
View file

@ -1,267 +1,334 @@
{ { pkgs ? import <nixpkgs> {}
pkgs ? import <nixpkgs> { }, , lib ? pkgs.lib
lib ? pkgs.lib, , stdenv ? pkgs.stdenv
stdenv ? pkgs.stdenv,
}: }:
let let
addSetupTools = self: super: drv: drv.overrideAttrs(old: { addSetupTools = self: super: drv: drv.overrideAttrs (
buildInputs = old.buildInputs ++ [ old: {
self.setuptools_scm buildInputs = old.buildInputs ++ [
]; self.setuptools_scm
}); ];
}
);
getAttrDefault = attribute: set: default: getAttrDefault = attribute: set: default:
if builtins.hasAttr attribute set if builtins.hasAttr attribute set
then builtins.getAttr attribute set then builtins.getAttr attribute set
else default; else default;
in { in
{
asciimatics = self: super: drv: drv.overrideAttrs(old: { asciimatics = self: super: drv: drv.overrideAttrs (
buildInputs = old.buildInputs ++ [ old: {
self.setuptools_scm buildInputs = old.buildInputs ++ [
]; self.setuptools_scm
}); ];
}
);
av = self: super: drv: drv.overrideAttrs(old: { av = self: super: drv: drv.overrideAttrs (
nativeBuildInputs = old.nativeBuildInputs ++ [ old: {
pkgs.pkgconfig nativeBuildInputs = old.nativeBuildInputs ++ [
]; pkgs.pkgconfig
buildInputs = old.buildInputs ++ [ pkgs.ffmpeg_4 ]; ];
}); buildInputs = old.buildInputs ++ [ pkgs.ffmpeg_4 ];
}
);
bcrypt = self: super: drv: drv.overrideAttrs(old: { bcrypt = self: super: drv: drv.overrideAttrs (
buildInputs = old.buildInputs ++ [ pkgs.libffi ]; old: {
}); buildInputs = old.buildInputs ++ [ pkgs.libffi ];
}
);
cffi = self: super: drv: drv.overrideAttrs(old: { cffi = self: super: drv: drv.overrideAttrs (
buildInputs = old.buildInputs ++ [ pkgs.libffi ]; old: {
}); buildInputs = old.buildInputs ++ [ pkgs.libffi ];
}
);
cftime = self: super: drv: drv.overrideAttrs(old: { cftime = self: super: drv: drv.overrideAttrs (
buildInputs = old.buildInputs ++ [ old: {
self.cython buildInputs = old.buildInputs ++ [
]; self.cython
}); ];
}
);
configparser = addSetupTools; configparser = addSetupTools;
cbor2 = addSetupTools; cbor2 = addSetupTools;
cryptography = self: super: drv: drv.overrideAttrs(old: { cryptography = self: super: drv: drv.overrideAttrs (
buildInputs = old.buildInputs ++ [ pkgs.openssl ]; old: {
}); buildInputs = old.buildInputs ++ [ pkgs.openssl ];
}
);
django = (self: super: drv: drv.overrideAttrs(old: { django = (
propagatedNativeBuildInputs = (getAttrDefault "propagatedNativeBuildInputs" old []) self: super: drv: drv.overrideAttrs (
++ [ pkgs.gettext ]; old: {
})); propagatedNativeBuildInputs = (getAttrDefault "propagatedNativeBuildInputs" old [])
++ [ pkgs.gettext ];
}
)
);
django-bakery = self: super: drv: drv.overrideAttrs(old: { django-bakery = self: super: drv: drv.overrideAttrs (
configurePhase = '' old: {
if ! test -e LICENSE; then configurePhase = ''
touch LICENSE if ! test -e LICENSE; then
fi touch LICENSE
'' + (getAttrDefault "configurePhase" old ""); fi
}); '' + (getAttrDefault "configurePhase" old "");
}
);
# Environment markers are not always included (depending on how a dep was defined) # Environment markers are not always included (depending on how a dep was defined)
enum34 = self: super: drv: if self.pythonAtLeast "3.4" then null else drv; enum34 = self: super: drv: if self.pythonAtLeast "3.4" then null else drv;
grandalf = self: super: drv: drv.overrideAttrs(old: { grandalf = self: super: drv: drv.overrideAttrs (
postPatch = '' old: {
substituteInPlace setup.py --replace "setup_requires=['pytest-runner',]," "setup_requires=[]," || true postPatch = ''
''; substituteInPlace setup.py --replace "setup_requires=['pytest-runner',]," "setup_requires=[]," || true
}); '';
}
);
horovod = self: super: drv: drv.overrideAttrs(old: { horovod = self: super: drv: drv.overrideAttrs (
propagatedBuildInputs = old.propagatedBuildInputs ++ [ pkgs.openmpi ]; old: {
}); propagatedBuildInputs = old.propagatedBuildInputs ++ [ pkgs.openmpi ];
}
);
hypothesis = addSetupTools; hypothesis = addSetupTools;
importlib-metadata = addSetupTools; importlib-metadata = addSetupTools;
inflect = self: super: drv: drv.overrideAttrs(old: { inflect = self: super: drv: drv.overrideAttrs (
buildInputs = old.buildInputs ++ [ old: {
self.setuptools_scm buildInputs = old.buildInputs ++ [
]; self.setuptools_scm
}); ];
}
);
jsonschema = addSetupTools; jsonschema = addSetupTools;
keyring = addSetupTools; keyring = addSetupTools;
lap = self: super: drv: drv.overrideAttrs(old: { lap = self: super: drv: drv.overrideAttrs (
propagatedBuildInputs = old.propagatedBuildInputs ++ [ old: {
self.numpy propagatedBuildInputs = old.propagatedBuildInputs ++ [
]; self.numpy
}); ];
}
llvmlite = self: super: drv: drv.overrideAttrs(old: { );
nativeBuildInputs = old.nativeBuildInputs ++ [ pkgs.llvm ];
# Disable static linking llvmlite = self: super: drv: drv.overrideAttrs (
# https://github.com/numba/llvmlite/issues/93 old: {
postPatch = '' nativeBuildInputs = old.nativeBuildInputs ++ [ pkgs.llvm ];
substituteInPlace ffi/Makefile.linux --replace "-static-libstdc++" ""
substituteInPlace llvmlite/tests/test_binding.py --replace "test_linux" "nope" # Disable static linking
''; # https://github.com/numba/llvmlite/issues/93
postPatch = ''
substituteInPlace ffi/Makefile.linux --replace "-static-libstdc++" ""
# Set directory containing llvm-config binary substituteInPlace llvmlite/tests/test_binding.py --replace "test_linux" "nope"
preConfigure = '' '';
export LLVM_CONFIG=${pkgs.llvm}/bin/llvm-config
'';
__impureHostDeps = pkgs.stdenv.lib.optionals pkgs.stdenv.isDarwin [ "/usr/lib/libm.dylib" ]; # Set directory containing llvm-config binary
preConfigure = ''
export LLVM_CONFIG=${pkgs.llvm}/bin/llvm-config
'';
passthru.llvm = pkgs.llvm; __impureHostDeps = pkgs.stdenv.lib.optionals pkgs.stdenv.isDarwin [ "/usr/lib/libm.dylib" ];
});
lockfile = self: super: drv: drv.overrideAttrs(old: { passthru.llvm = pkgs.llvm;
propagatedBuildInputs = old.propagatedBuildInputs ++ [ self.pbr ]; }
}); );
lxml = self: super: drv: drv.overrideAttrs(old: { lockfile = self: super: drv: drv.overrideAttrs (
nativeBuildInputs = with pkgs; old.nativeBuildInputs ++ [ pkgconfig libxml2.dev libxslt.dev ]; old: {
buildInputs = with pkgs; old.buildInputs ++ [ libxml2 libxslt ]; propagatedBuildInputs = old.propagatedBuildInputs ++ [ self.pbr ];
}); }
);
markupsafe = self: super: drv: drv.overrideAttrs(old: { lxml = self: super: drv: drv.overrideAttrs (
src = old.src.override { pname = builtins.replaceStrings [ "markupsafe" ] [ "MarkupSafe"] old.pname; }; old: {
}); nativeBuildInputs = with pkgs; old.nativeBuildInputs ++ [ pkgconfig libxml2.dev libxslt.dev ];
buildInputs = with pkgs; old.buildInputs ++ [ libxml2 libxslt ];
}
);
matplotlib = self: super: drv: drv.overrideAttrs(old: { markupsafe = self: super: drv: drv.overrideAttrs (
NIX_CFLAGS_COMPILE = stdenv.lib.optionalString stdenv.isDarwin "-I${pkgs.libcxx}/include/c++/v1"; old: {
src = old.src.override { pname = builtins.replaceStrings [ "markupsafe" ] [ "MarkupSafe" ] old.pname; };
}
);
XDG_RUNTIME_DIR = "/tmp"; matplotlib = self: super: drv: drv.overrideAttrs (
old: {
NIX_CFLAGS_COMPILE = stdenv.lib.optionalString stdenv.isDarwin "-I${pkgs.libcxx}/include/c++/v1";
nativeBuildInputs = old.nativeBuildInputs ++ [ XDG_RUNTIME_DIR = "/tmp";
pkgs.pkgconfig
];
propagatedBuildInputs = old.propagatedBuildInputs ++ [ nativeBuildInputs = old.nativeBuildInputs ++ [
pkgs.libpng pkgs.pkgconfig
pkgs.freetype ];
];
inherit (super.matplotlib) patches; propagatedBuildInputs = old.propagatedBuildInputs ++ [
}); pkgs.libpng
pkgs.freetype
];
mccabe = self: super: drv: drv.overrideAttrs(old: { inherit (super.matplotlib) patches;
postPatch = '' }
substituteInPlace setup.py --replace "setup_requires=['pytest-runner']," "setup_requires=[]," || true );
'';
});
netcdf4 = self: super: drv: drv.overrideAttrs(old: { mccabe = self: super: drv: drv.overrideAttrs (
buildInputs = old.buildInputs ++ [ old: {
self.cython postPatch = ''
]; substituteInPlace setup.py --replace "setup_requires=['pytest-runner']," "setup_requires=[]," || true
'';
}
);
propagatedBuildInputs = old.propagatedBuildInputs ++ [ netcdf4 = self: super: drv: drv.overrideAttrs (
pkgs.zlib old: {
pkgs.netcdf buildInputs = old.buildInputs ++ [
pkgs.hdf5 self.cython
pkgs.curl ];
pkgs.libjpeg
];
# Variables used to configure the build process propagatedBuildInputs = old.propagatedBuildInputs ++ [
USE_NCCONFIG="0"; pkgs.zlib
HDF5_DIR = lib.getDev pkgs.hdf5; pkgs.netcdf
NETCDF4_DIR = pkgs.netcdf; pkgs.hdf5
CURL_DIR = pkgs.curl.dev; pkgs.curl
JPEG_DIR = pkgs.libjpeg.dev; pkgs.libjpeg
}); ];
numpy = self: super: drv: drv.overrideAttrs(old: let # Variables used to configure the build process
blas = pkgs.openblasCompat; USE_NCCONFIG = "0";
blasImplementation = lib.nameFromURL blas.name "-"; HDF5_DIR = lib.getDev pkgs.hdf5;
cfg = pkgs.writeTextFile { NETCDF4_DIR = pkgs.netcdf;
name = "site.cfg"; CURL_DIR = pkgs.curl.dev;
text = (lib.generators.toINI {} { JPEG_DIR = pkgs.libjpeg.dev;
${blasImplementation} = { }
include_dirs = "${blas}/include"; );
library_dirs = "${blas}/lib";
} // lib.optionalAttrs (blasImplementation == "mkl") { numpy = self: super: drv: drv.overrideAttrs (
mkl_libs = "mkl_rt"; old: let
lapack_libs = ""; blas = pkgs.openblasCompat;
blasImplementation = lib.nameFromURL blas.name "-";
cfg = pkgs.writeTextFile {
name = "site.cfg";
text = (
lib.generators.toINI {} {
${blasImplementation} = {
include_dirs = "${blas}/include";
library_dirs = "${blas}/lib";
} // lib.optionalAttrs (blasImplementation == "mkl") {
mkl_libs = "mkl_rt";
lapack_libs = "";
};
}
);
};
in
{
nativeBuildInputs = old.nativeBuildInputs ++ [ pkgs.gfortran ];
buildInputs = old.buildInputs ++ [ blas ];
enableParallelBuilding = true;
preBuild = ''
ln -s ${cfg} site.cfg
'';
passthru = {
blas = blas;
inherit blasImplementation cfg;
}; };
}); }
}; );
in {
nativeBuildInputs = old.nativeBuildInputs ++ [ pkgs.gfortran ];
buildInputs = old.buildInputs ++ [ blas ];
enableParallelBuilding = true;
preBuild = ''
ln -s ${cfg} site.cfg
'';
passthru = {
blas = blas;
inherit blasImplementation cfg;
};
});
pillow = self: super: drv: drv.overrideAttrs(old: { pillow = self: super: drv: drv.overrideAttrs (
nativeBuildInputs = [ pkgs.pkgconfig ] ++ old.nativeBuildInputs; old: {
buildInputs = with pkgs; [ freetype libjpeg zlib libtiff libwebp tcl lcms2 ] ++ old.buildInputs; nativeBuildInputs = [ pkgs.pkgconfig ] ++ old.nativeBuildInputs;
}); buildInputs = with pkgs; [ freetype libjpeg zlib libtiff libwebp tcl lcms2 ] ++ old.buildInputs;
}
);
pluggy = addSetupTools; pluggy = addSetupTools;
psycopg2 = self: super: drv: drv.overrideAttrs(old: { psycopg2 = self: super: drv: drv.overrideAttrs (
nativeBuildInputs = old.nativeBuildInputs ++ [ pkgs.postgresql ]; old: {
}); nativeBuildInputs = old.nativeBuildInputs ++ [ pkgs.postgresql ];
}
);
psycopg2-binary = self: super: drv: drv.overrideAttrs(old: { psycopg2-binary = self: super: drv: drv.overrideAttrs (
nativeBuildInputs = old.nativeBuildInputs ++ [ pkgs.postgresql ]; old: {
}); nativeBuildInputs = old.nativeBuildInputs ++ [ pkgs.postgresql ];
}
);
py = addSetupTools; py = addSetupTools;
pyarrow = self: super: drv: drv.overrideAttrs(old: { pyarrow = self: super: drv: drv.overrideAttrs (
buildInputs = old.buildInputs ++ [ old: {
self.cython buildInputs = old.buildInputs ++ [
]; self.cython
}); ];
}
);
pycairo = self: super: drv: (drv.overridePythonAttrs(_: { pycairo = self: super: drv: (
format = "other"; drv.overridePythonAttrs (
})).overrideAttrs(old: { _: {
format = "other";
}
)
).overrideAttrs (
old: {
nativeBuildInputs = old.nativeBuildInputs ++ [ nativeBuildInputs = old.nativeBuildInputs ++ [
pkgs.meson pkgs.meson
pkgs.ninja pkgs.ninja
pkgs.pkgconfig pkgs.pkgconfig
]; ];
propagatedBuildInputs = old.propagatedBuildInputs ++ [ propagatedBuildInputs = old.propagatedBuildInputs ++ [
pkgs.cairo pkgs.cairo
pkgs.xlibsWrapper pkgs.xlibsWrapper
]; ];
mesonFlags = [ "-Dpython=${if self.isPy3k then "python3" else "python"}" ]; mesonFlags = [ "-Dpython=${if self.isPy3k then "python3" else "python"}" ];
}); }
);
pycocotools = self: super: drv: drv.overrideAttrs(old: { pycocotools = self: super: drv: drv.overrideAttrs (
buildInputs = old.buildInputs ++ [ old: {
self.cython buildInputs = old.buildInputs ++ [
self.numpy self.cython
]; self.numpy
}); ];
}
);
pygobject = self: super: drv: drv.overrideAttrs(old: { pygobject = self: super: drv: drv.overrideAttrs (
nativeBuildInputs = old.nativeBuildInputs ++ [ pkgs.pkgconfig ]; old: {
buildInputs = old.buildInputs ++ [ pkgs.glib pkgs.gobject-introspection ]; nativeBuildInputs = old.nativeBuildInputs ++ [ pkgs.pkgconfig ];
}); buildInputs = old.buildInputs ++ [ pkgs.glib pkgs.gobject-introspection ];
}
);
pyopenssl = self: super: drv: drv.overrideAttrs(old: { pyopenssl = self: super: drv: drv.overrideAttrs (
buildInputs = old.buildInputs ++ [ pkgs.openssl ]; old: {
}); buildInputs = old.buildInputs ++ [ pkgs.openssl ];
}
);
pytest = addSetupTools; pytest = addSetupTools;
@ -269,50 +336,62 @@ in {
python-dateutil = addSetupTools; python-dateutil = addSetupTools;
python-prctl = self: super: drv: drv.overrideAttrs(old: { python-prctl = self: super: drv: drv.overrideAttrs (
buildInputs = old.buildInputs ++ [ old: {
self.setuptools_scm buildInputs = old.buildInputs ++ [
pkgs.libcap self.setuptools_scm
]; pkgs.libcap
}); ];
}
);
scaleapi = self: super: drv: drv.overrideAttrs(old: { scaleapi = self: super: drv: drv.overrideAttrs (
postPatch = '' old: {
substituteInPlace setup.py --replace "install_requires = ['requests>=2.4.2', 'enum34']" "install_requires = ['requests>=2.4.2']" || true postPatch = ''
''; substituteInPlace setup.py --replace "install_requires = ['requests>=2.4.2', 'enum34']" "install_requires = ['requests>=2.4.2']" || true
}); '';
}
);
scipy = self: super: drv: drv.overrideAttrs(old: { scipy = self: super: drv: drv.overrideAttrs (
nativeBuildInputs = old.nativeBuildInputs ++ [ pkgs.gfortran ]; old: {
setupPyBuildFlags = [ "--fcompiler='gnu95'" ]; nativeBuildInputs = old.nativeBuildInputs ++ [ pkgs.gfortran ];
enableParallelBuilding = true; setupPyBuildFlags = [ "--fcompiler='gnu95'" ];
buildInputs = old.buildInputs ++ [ self.numpy.blas ]; enableParallelBuilding = true;
preConfigure = '' buildInputs = old.buildInputs ++ [ self.numpy.blas ];
sed -i '0,/from numpy.distutils.core/s//import setuptools;from numpy.distutils.core/' setup.py preConfigure = ''
export NPY_NUM_BUILD_JOBS=$NIX_BUILD_CORES sed -i '0,/from numpy.distutils.core/s//import setuptools;from numpy.distutils.core/' setup.py
''; export NPY_NUM_BUILD_JOBS=$NIX_BUILD_CORES
preBuild = '' '';
ln -s ${self.numpy.cfg} site.cfg preBuild = ''
''; ln -s ${self.numpy.cfg} site.cfg
}); '';
}
);
shapely = self: super: drv: drv.overrideAttrs(old: { shapely = self: super: drv: drv.overrideAttrs (
buildInputs = old.buildInputs ++ [ pkgs.geos self.cython ]; old: {
inherit (super.shapely) patches GEOS_LIBRARY_PATH; buildInputs = old.buildInputs ++ [ pkgs.geos self.cython ];
}); inherit (super.shapely) patches GEOS_LIBRARY_PATH;
}
);
six = addSetupTools; six = addSetupTools;
urwidtrees = self: super: drv: drv.overrideAttrs(old: { urwidtrees = self: super: drv: drv.overrideAttrs (
propagatedBuildInputs = old.propagatedBuildInputs ++ [ old: {
self.urwid propagatedBuildInputs = old.propagatedBuildInputs ++ [
]; self.urwid
}); ];
}
);
# Break setuptools infinite recursion because of non-bootstrapped pip # Break setuptools infinite recursion because of non-bootstrapped pip
wheel = self: super: drv: super.wheel.overridePythonAttrs(_: { wheel = self: super: drv: super.wheel.overridePythonAttrs (
inherit (drv) pname name version src; _: {
}); inherit (drv) pname name version src;
}
);
zipp = addSetupTools; zipp = addSetupTools;
} }

142
pep508.nix
View file

@ -14,23 +14,25 @@ let
posNew = acc.pos + 1; posNew = acc.pos + 1;
isOpen = acc.openP == 0; isOpen = acc.openP == 0;
startPos = if isOpen then posNew else acc.startPos; startPos = if isOpen then posNew else acc.startPos;
in acc // { in
inherit startPos; acc // {
exprs = acc.exprs ++ [ (substr acc.exprPos (acc.pos - 1) acc.expr) ]; inherit startPos;
pos = posNew; exprs = acc.exprs ++ [ (substr acc.exprPos (acc.pos - 1) acc.expr) ];
openP = acc.openP + 1; pos = posNew;
} openP = acc.openP + 1;
}
) else if c == ")" then ( ) else if c == ")" then (
let let
openP = acc.openP - 1; openP = acc.openP - 1;
exprs = findSubExpressions (substr acc.startPos acc.pos acc.expr); exprs = findSubExpressions (substr acc.startPos acc.pos acc.expr);
in acc // { in
inherit openP; acc // {
pos = acc.pos + 1; inherit openP;
exprs = if openP == 0 then acc.exprs ++ [ exprs ] else acc.exprs; pos = acc.pos + 1;
exprPos = if openP == 0 then acc.pos + 1 else acc.exprPos; exprs = if openP == 0 then acc.exprs ++ [ exprs ] else acc.exprs;
} exprPos = if openP == 0 then acc.pos + 1 else acc.exprPos;
) else acc // {pos = acc.pos + 1;} }
) else acc // { pos = acc.pos + 1; }
); );
# Make a tree out of expression groups (parens) # Make a tree out of expression groups (parens)
@ -45,12 +47,15 @@ let
} (lib.stringToCharacters expr); } (lib.stringToCharacters expr);
tailExpr = (substr acc.exprPos acc.pos expr); tailExpr = (substr acc.exprPos acc.pos expr);
tailExprs = if tailExpr != "" then [ tailExpr ] else []; tailExprs = if tailExpr != "" then [ tailExpr ] else [];
in acc.exprs ++ tailExprs; in
acc.exprs ++ tailExprs;
parseExpressions = exprs: let parseExpressions = exprs: let
splitCond = (s: builtins.map splitCond = (
(x: stripStr (if builtins.typeOf x == "list" then (builtins.elemAt x 0) else x)) s: builtins.map
(builtins.split " (and|or) " (s + " "))); (x: stripStr (if builtins.typeOf x == "list" then (builtins.elemAt x 0) else x))
(builtins.split " (and|or) " (s + " "))
);
mapfn = expr: ( mapfn = expr: (
if (builtins.match "^ ?$" expr != null) then null # Filter empty if (builtins.match "^ ?$" expr != null) then null # Filter empty
@ -66,32 +71,35 @@ let
parse = expr: builtins.filter (x: x != null) (builtins.map mapfn (splitCond expr)); parse = expr: builtins.filter (x: x != null) (builtins.map mapfn (splitCond expr));
in builtins.foldl' (acc: v: acc ++ ( in
if builtins.typeOf v == "string" then parse v else [(parseExpressions v)] builtins.foldl' (
)) [] exprs; acc: v: acc ++ (
if builtins.typeOf v == "string" then parse v else [ (parseExpressions v) ]
)
) [] exprs;
# Transform individual expressions to structured expressions # Transform individual expressions to structured expressions
# This function also performs variable substitution, replacing environment markers with their explicit values # This function also performs variable substitution, replacing environment markers with their explicit values
transformExpressions = exprs: let transformExpressions = exprs: let
variables = { variables = {
os_name = "posix"; # TODO: Check other platforms os_name = "posix"; # TODO: Check other platforms
sys_platform = ( sys_platform = (
if stdenv.isLinux then "linux" if stdenv.isLinux then "linux"
else if stdenv.isDarwin then "darwin" else if stdenv.isDarwin then "darwin"
else throw "Unsupported platform" else throw "Unsupported platform"
); );
platform_machine = stdenv.platform.kernelArch; platform_machine = stdenv.platform.kernelArch;
platform_python_implementation = "CPython"; # Only CPython supported for now platform_python_implementation = "CPython"; # Only CPython supported for now
platform_release = ""; # Field not reproducible platform_release = ""; # Field not reproducible
platform_system = ( platform_system = (
if stdenv.isLinux then "Linux" if stdenv.isLinux then "Linux"
else if stdenv.isDarwin then "Darwin" else if stdenv.isDarwin then "Darwin"
else throw "Unsupported platform" else throw "Unsupported platform"
); );
platform_version = ""; # Field not reproducible platform_version = ""; # Field not reproducible
python_version = python.passthru.pythonVersion; python_version = python.passthru.pythonVersion;
python_full_version = python.version; python_full_version = python.version;
implementation_name = "cpython"; # Only cpython supported for now implementation_name = "cpython"; # Only cpython supported for now
implementation_version = python.version; implementation_version = python.version;
extra = ""; extra = "";
}; };
@ -103,23 +111,27 @@ let
substituteVar substituteVar
]; ];
in if builtins.typeOf exprs == "set" then ( in
if exprs.type == "expr" then (let if builtins.typeOf exprs == "set" then (
mVal = ''[a-zA-Z0-9\'"_\. ]+''; if exprs.type == "expr" then (
mOp = "in|[!=<>]+"; let
e = stripStr exprs.value; mVal = ''[a-zA-Z0-9\'"_\. ]+'';
m = builtins.map stripStr (builtins.match ''^(${mVal}) *(${mOp}) *(${mVal})$'' e); mOp = "in|[!=<>]+";
in { e = stripStr exprs.value;
type = "expr"; m = builtins.map stripStr (builtins.match ''^(${mVal}) *(${mOp}) *(${mVal})$'' e);
value = { in
op = builtins.elemAt m 1; {
values = [ type = "expr";
(processVar (builtins.elemAt m 0)) value = {
(processVar (builtins.elemAt m 2)) op = builtins.elemAt m 1;
]; values = [
}; (processVar (builtins.elemAt m 0))
}) else exprs (processVar (builtins.elemAt m 2))
) else builtins.map transformExpressions exprs; ];
};
}
) else exprs
) else builtins.map transformExpressions exprs;
# Recursively eval all expressions # Recursively eval all expressions
evalExpressions = exprs: let evalExpressions = exprs: let
@ -142,17 +154,22 @@ let
"===" = null; "===" = null;
"in" = x: y: let "in" = x: y: let
values = builtins.filter (x: builtins.typeOf x == "string") (builtins.split " " (unmarshal y)); values = builtins.filter (x: builtins.typeOf x == "string") (builtins.split " " (unmarshal y));
in builtins.elem (unmarshal x) values; in
builtins.elem (unmarshal x) values;
}; };
in if builtins.typeOf exprs == "set" then ( in
if exprs.type == "expr" then (let if builtins.typeOf exprs == "set" then (
expr = exprs; if exprs.type == "expr" then (
result = (op."${expr.value.op}") (builtins.elemAt expr.value.values 0) (builtins.elemAt expr.value.values 1); let
in { expr = exprs;
type = "value"; result = (op."${expr.value.op}") (builtins.elemAt expr.value.values 0) (builtins.elemAt expr.value.values 1);
value = result; in
}) else exprs {
) else builtins.map evalExpressions exprs; type = "value";
value = result;
}
) else exprs
) else builtins.map evalExpressions exprs;
# Now that we have performed an eval all that's left to do is to concat the graph into a single bool # Now that we have performed an eval all that's left to do is to concat the graph into a single bool
reduceExpressions = exprs: let reduceExpressions = exprs: let
@ -177,17 +194,22 @@ let
value = true; value = true;
cond = "and"; cond = "and";
} v; } v;
in acc // { in
value = cond."${acc.cond}" acc.value ret.value; acc // {
} value = cond."${acc.cond}" acc.value ret.value;
}
) else throw "Unsupported type" ) else throw "Unsupported type"
); );
in (builtins.foldl' reduceExpressionsFun { in
value = true; (
cond = "and"; builtins.foldl' reduceExpressionsFun {
} exprs).value; value = true;
cond = "and";
} exprs
).value;
in e: builtins.foldl' (acc: v: v acc) e [ in
e: builtins.foldl' (acc: v: v acc) e [
findSubExpressions findSubExpressions
parseExpressions parseExpressions
transformExpressions transformExpressions

74
semver.nix
View file

@ -6,7 +6,8 @@ let
# Replace a list entry at defined index with set value # Replace a list entry at defined index with set value
ireplace = idx: value: list: let ireplace = idx: value: list: let
inherit (builtins) genList length; inherit (builtins) genList length;
in genList (i: if i == idx then value else (elemAt list i)) (length list); in
genList (i: if i == idx then value else (elemAt list i)) (length list);
operators = let operators = let
matchWildCard = s: match "([^\*])(\.[\*])" s; matchWildCard = s: match "([^\*])(\.[\*])" s;
@ -15,7 +16,8 @@ let
ver = builtins.splitVersion v; ver = builtins.splitVersion v;
minor = builtins.toString (lib.toInt (elemAt ver idx) + 1); minor = builtins.toString (lib.toInt (elemAt ver idx) + 1);
upper = builtins.concatStringsSep "." (ireplace idx minor ver); upper = builtins.concatStringsSep "." (ireplace idx minor ver);
in operators.">=" version v && operators."<" version upper; in
operators.">=" version v && operators."<" version upper;
dropWildcardPrecision = f: version: constraint: let dropWildcardPrecision = f: version: constraint: let
m = matchWildCard constraint; m = matchWildCard constraint;
hasWildcard = m != null; hasWildcard = m != null;
@ -23,21 +25,23 @@ let
v = v =
if hasWildcard then (builtins.substring 0 (builtins.stringLength c) version) if hasWildcard then (builtins.substring 0 (builtins.stringLength c) version)
else version; else version;
in f v c; in
in { f v c;
# Prefix operators in
"==" = dropWildcardPrecision (mkComparison 0); {
">" = dropWildcardPrecision (mkComparison 1); # Prefix operators
"<" = dropWildcardPrecision (mkComparison (-1)); "==" = dropWildcardPrecision (mkComparison 0);
"!=" = v: c: ! operators."==" v c; ">" = dropWildcardPrecision (mkComparison 1);
">=" = v: c: operators."==" v c || operators.">" v c; "<" = dropWildcardPrecision (mkComparison (-1));
"<=" = v: c: operators."==" v c || operators."<" v c; "!=" = v: c: ! operators."==" v c;
# Semver specific operators ">=" = v: c: operators."==" v c || operators.">" v c;
"~" = mkIdxComparison 1; # "<=" = v: c: operators."==" v c || operators."<" v c;
"^" = mkIdxComparison 0; # Semver specific operators
# Infix operators "~" = mkIdxComparison 1; #
"-" = version: v: operators.">=" version v.vl && operators."<=" version v.vu; "^" = mkIdxComparison 0;
}; # Infix operators
"-" = version: v: operators.">=" version v.vl && operators."<=" version v.vu;
};
re = { re = {
operators = "([=><!~\^]+)"; operators = "([=><!~\^]+)";
@ -50,23 +54,27 @@ let
mPre = match "${re.operators} *${re.version}" constraintStr; mPre = match "${re.operators} *${re.version}" constraintStr;
# There is also an infix operator to match ranges # There is also an infix operator to match ranges
mIn = match "${re.version} *(-) *${re.version}" constraintStr; mIn = match "${re.version} *(-) *${re.version}" constraintStr;
in ( in
if mPre != null then { (
op = elemAt mPre 0; if mPre != null then {
v = elemAt mPre 1; op = elemAt mPre 0;
} v = elemAt mPre 1;
# Infix operators are range matches }
else if mIn != null then { # Infix operators are range matches
op = elemAt mIn 1; else if mIn != null then {
v = { op = elemAt mIn 1;
vl = (elemAt mIn 0); v = {
vu = (elemAt mIn 2); vl = (elemAt mIn 0);
}; vu = (elemAt mIn 2);
} };
else throw "Constraint \"${constraintStr}\" could not be parsed"); }
else throw "Constraint \"${constraintStr}\" could not be parsed"
);
satisfies = version: constraint: let satisfies = version: constraint: let
inherit (parseConstraint constraint) op v; inherit (parseConstraint constraint) op v;
in if constraint == "*" then true else operators."${op}" version v; in
if constraint == "*" then true else operators."${op}" version v;
in { inherit satisfies; } in
{ inherit satisfies; }

10
shell.nix
View file

@ -3,8 +3,8 @@ let
poetry2nix = import ./. { inherit pkgs; inherit poetry; }; poetry2nix = import ./. { inherit pkgs; inherit poetry; };
poetry = pkgs.callPackage ./pkgs/poetry { python = pkgs.python3; inherit poetry2nix; }; poetry = pkgs.callPackage ./pkgs/poetry { python = pkgs.python3; inherit poetry2nix; };
in in
pkgs.mkShell { pkgs.mkShell {
buildInputs = [ buildInputs = [
poetry poetry
]; ];
} }

12
tests/default.nix
View file

@ -3,9 +3,9 @@ let
poetry = pkgs.callPackage ../pkgs/poetry { python = pkgs.python3; inherit poetry2nix; }; poetry = pkgs.callPackage ../pkgs/poetry { python = pkgs.python3; inherit poetry2nix; };
poetry2nix = import ./.. { inherit pkgs; inherit poetry; }; poetry2nix = import ./.. { inherit pkgs; inherit poetry; };
in in
{ {
trivial = pkgs.callPackage ./override-support { inherit poetry2nix; }; trivial = pkgs.callPackage ./override-support { inherit poetry2nix; };
override = pkgs.callPackage ./override-support { inherit poetry2nix; }; override = pkgs.callPackage ./override-support { inherit poetry2nix; };
top-packages-1 = pkgs.callPackage ./common-pkgs-1 { inherit poetry2nix; }; top-packages-1 = pkgs.callPackage ./common-pkgs-1 { inherit poetry2nix; };
top-packages-2 = pkgs.callPackage ./common-pkgs-2 { inherit poetry2nix; }; top-packages-2 = pkgs.callPackage ./common-pkgs-2 { inherit poetry2nix; };
} }

18
tests/override-support/default.nix
View file

@ -7,14 +7,16 @@ let
poetryLock = ./poetry.lock; poetryLock = ./poetry.lock;
src = lib.cleanSource ./.; src = lib.cleanSource ./.;
overrides = poetry2nix.defaultPoetryOverrides // { overrides = poetry2nix.defaultPoetryOverrides // {
alembic = self: super: drv: drv.overrideAttrs(old: { alembic = self: super: drv: drv.overrideAttrs (
TESTING_FOOBAR = 42; old: {
}); TESTING_FOOBAR = 42;
}
);
}; };
}; };
in in
runCommand "test" {} '' runCommand "test" {} ''
x=${builtins.toString (pyApp.pythonPackages.alembic.TESTING_FOOBAR)} x=${builtins.toString (pyApp.pythonPackages.alembic.TESTING_FOOBAR)}
[ "$x" = "42" ] || exit 1 [ "$x" = "42" ] || exit 1
mkdir $out mkdir $out
'' ''