2016-02-21 19:13:44 +00:00
# Python
## User Guide
### Using Python
2017-08-26 09:21:30 +00:00
#### Overview
Several versions of the Python interpreter are available on Nix, as well as a
high amount of packages. The attribute `python` refers to the default
interpreter, which is currently CPython 2.7. It is also possible to refer to
specific versions, e.g. `python35` refers to CPython 3.5, and `pypy` refers to
the default PyPy interpreter.
Python is used a lot, and in different ways. This affects also how it is
packaged. In the case of Python on Nix, an important distinction is made between
whether the package is considered primarily an application, or whether it should
be used as a library, i.e., of primary interest are the modules in
`site-packages` that should be importable.
In the Nixpkgs tree Python applications can be found throughout, depending on
what they do, and are called from the main package set. Python libraries,
however, are in separate sets, with one set per interpreter version.
The interpreters have several common attributes. One of these attributes is
`pkgs` , which is a package set of Python libraries for this specific
interpreter. E.g., the `toolz` package corresponding to the default interpreter
is `python.pkgs.toolz` , and the CPython 3.5 version is `python35.pkgs.toolz` .
The main package set contains aliases to these package sets, e.g.
`pythonPackages` refers to `python.pkgs` and `python35Packages` to
`python35.pkgs` .
2016-02-21 19:13:44 +00:00
#### Installing Python and packages
2017-08-26 09:21:30 +00:00
The Nix and NixOS manuals explain how packages are generally installed. In the
case of Python and Nix, it is important to make a distinction between whether the
package is considered an application or a library.
2016-02-21 19:13:44 +00:00
2017-08-26 09:21:30 +00:00
Applications on Nix are typically installed into your user
2016-02-21 19:13:44 +00:00
profile imperatively using `nix-env -i` , and on NixOS declaratively by adding the
package name to `environment.systemPackages` in `/etc/nixos/configuration.nix` .
Dependencies such as libraries are automatically installed and should not be
installed explicitly.
The same goes for Python applications and libraries. Python applications can be
2017-08-26 09:21:30 +00:00
installed in your profile. But Python libraries you would like to use for
development cannot be installed, at least not individually, because they won't
be able to find each other resulting in import errors. Instead, it is possible
to create an environment with `python.buildEnv` or `python.withPackages` where
the interpreter and other executables are able to find each other and all of the
modules.
2016-02-21 19:13:44 +00:00
2017-08-26 09:21:30 +00:00
In the following examples we create an environment with Python 3.5, `numpy` and
`toolz` . As you may imagine, there is one limitation here, and that's that
you can install only one environment at a time. You will notice the complaints
about collisions when you try to install a second environment.
2016-02-21 19:13:44 +00:00
2017-08-26 09:21:30 +00:00
##### Environment defined in separate `.nix` file
2016-02-21 19:13:44 +00:00
2017-08-26 09:21:30 +00:00
Create a file, e.g. `build.nix` , with the following expression
```nix
with import < nixpkgs > {};
python35.withPackages (ps: with ps; [ numpy toolz ])
```
and install it in your profile with
```shell
nix-env -if build.nix
```
Now you can use the Python interpreter, as well as the extra packages (`numpy`,
`toolz` ) that you added to the environment.
##### Environment defined in `~/.config/nixpkgs/config.nix`
If you prefer to, you could also add the environment as a package override to the Nixpkgs set, e.g.
using `config.nix` ,
```nix
{ # ...
packageOverrides = pkgs: with pkgs; {
myEnv = python35.withPackages (ps: with ps; [ numpy toolz ]);
};
}
```
and install it in your profile with
```shell
nix-env -iA nixpkgs.myEnv
```
The environment is is installed by referring to the attribute, and considering
the `nixpkgs` channel was used.
##### Environment defined in `/etc/nixos/configuration.nix`
For the sake of completeness, here's another example how to install the environment system-wide.
```nix
{ # ...
environment.systemPackages = with pkgs; [
(python35.withPackages(ps: with ps; [ numpy toolz ]))
];
}
2016-02-21 19:13:44 +00:00
```
2017-08-26 09:21:30 +00:00
#### Temporary Python environment with `nix-shell`
2016-02-21 19:13:44 +00:00
2017-08-26 09:21:30 +00:00
The examples in the previous section showed how to install a Python environment
into a profile. For development you may need to use multiple environments.
`nix-shell` gives the possibility to temporarily load another environment, akin
to `virtualenv` .
There are two methods for loading a shell with Python packages. The first and recommended method
is to create an environment with `python.buildEnv` or `python.withPackages` and load that. E.g.
```sh
$ nix-shell -p 'python35.withPackages(ps: with ps; [ numpy toolz ])'
```
opens a shell from which you can launch the interpreter
2016-02-21 19:13:44 +00:00
```sh
[nix-shell:~] python3
```
2017-08-26 09:21:30 +00:00
The other method, which is not recommended, does not create an environment and requires you to list the packages directly,
2016-02-21 19:13:44 +00:00
```sh
2017-08-26 09:21:30 +00:00
$ nix-shell -p python35.pkgs.numpy python35.pkgs.toolz
```
Again, it is possible to launch the interpreter from the shell.
The Python interpreter has the attribute `pkgs` which contains all Python libraries for that specific interpreter.
##### Load environment from `.nix` expression
As explained in the Nix manual, `nix-shell` can also load an
expression from a `.nix` file. Say we want to have Python 3.5, `numpy`
and `toolz` , like before, in an environment. Consider a `shell.nix` file
with
```nix
with import < nixpkgs > {};
2017-12-08 16:06:56 +00:00
(python35.withPackages (ps: [ps.numpy ps.toolz])).env
2016-02-21 19:13:44 +00:00
```
2017-08-26 09:21:30 +00:00
Executing `nix-shell` gives you again a Nix shell from which you can run Python.
What's happening here?
2016-02-21 19:13:44 +00:00
2017-08-26 09:21:30 +00:00
1. We begin with importing the Nix Packages collections. `import <nixpkgs>` imports the `<nixpkgs>` function, `{}` calls it and the `with` statement brings all attributes of `nixpkgs` in the local scope. These attributes form the main package set.
2. Then we create a Python 3.5 environment with the `withPackages` function.
3. The `withPackages` function expects us to provide a function as an argument that takes the set of all python packages and returns a list of packages to include in the environment. Here, we select the packages `numpy` and `toolz` from the package set.
2016-02-21 19:13:44 +00:00
2019-11-09 09:25:57 +00:00
To combine this with `mkShell` you can:
```nix
with import < nixpkgs > {};
let
pythonEnv = python35.withPackages (ps: [
ps.numpy
ps.toolz
]);
in mkShell {
buildInputs = [
pythonEnv
hello
];
}
```
2017-08-26 09:21:30 +00:00
##### Execute command with `--run`
A convenient option with `nix-shell` is the `--run`
option, with which you can execute a command in the `nix-shell` . We can
e.g. directly open a Python shell
```sh
$ nix-shell -p python35Packages.numpy python35Packages.toolz --run "python3"
```
or run a script
2016-02-21 19:13:44 +00:00
```sh
$ nix-shell -p python35Packages.numpy python35Packages.toolz --run "python3 myscript.py"
```
2017-08-26 09:21:30 +00:00
##### `nix-shell` as shebang
In fact, for the second use case, there is a more convenient method. You can
2016-02-21 19:13:44 +00:00
add a [shebang ](https://en.wikipedia.org/wiki/Shebang_(Unix )) to your script
2017-08-26 09:21:30 +00:00
specifying which dependencies `nix-shell` needs. With the following shebang, you
can just execute `./myscript.py` , and it will make available all dependencies and
2016-02-21 19:13:44 +00:00
run the script in the `python3` shell.
```py
#! /usr/bin/env nix-shell
2017-11-03 17:49:15 +00:00
#! nix-shell -i python3 -p "python3.withPackages(ps: [ps.numpy])"
2016-02-21 19:13:44 +00:00
import numpy
print(numpy.__version__)
```
### Developing with Python
2017-08-26 09:21:30 +00:00
Now that you know how to get a working Python environment with Nix, it is time
to go forward and start actually developing with Python. We will first have a
look at how Python packages are packaged on Nix. Then, we will look at how you
can use development mode with your code.
2016-02-21 19:13:44 +00:00
2017-08-26 09:21:30 +00:00
#### Packaging a library
2016-02-21 19:13:44 +00:00
2017-08-26 09:21:30 +00:00
With Nix all packages are built by functions. The main function in Nix for
building Python libraries is `buildPythonPackage` . Let's see how we can build the
`toolz` package.
2016-02-21 19:13:44 +00:00
```nix
2018-10-10 00:42:29 +00:00
{ lib, buildPythonPackage, fetchPypi }:
2016-02-21 19:13:44 +00:00
2019-03-19 00:01:54 +00:00
buildPythonPackage rec {
pname = "toolz";
version = "0.7.4";
src = fetchPypi {
inherit pname version;
sha256 = "43c2c9e5e7a16b6c88ba3088a9bfc82f7db8e13378be7c78d6c14a5f8ed05afd";
2016-02-21 19:13:44 +00:00
};
2019-03-19 00:01:54 +00:00
doCheck = false;
meta = with lib; {
homepage = https://github.com/pytoolz/toolz;
description = "List processing tools and functional utilities";
license = licenses.bsd3;
maintainers = with maintainers; [ fridh ];
};
2019-04-25 20:37:53 +00:00
}
2016-02-21 19:13:44 +00:00
```
What happens here? The function `buildPythonPackage` is called and as argument
2017-08-26 09:21:30 +00:00
it accepts a set. In this case the set is a recursive set, `rec` . One of the
arguments is the name of the package, which consists of a basename (generally
following the name on PyPi) and a version. Another argument, `src` specifies the
source, which in this case is fetched from PyPI using the helper function
`fetchPypi` . The argument `doCheck` is used to set whether tests should be run
when building the package. Furthermore, we specify some (optional) meta
information. The output of the function is a derivation.
An expression for `toolz` can be found in the Nixpkgs repository. As explained
in the introduction of this Python section, a derivation of `toolz` is available
for each interpreter version, e.g. `python35.pkgs.toolz` refers to the `toolz`
derivation corresponding to the CPython 3.5 interpreter.
2016-02-21 19:13:44 +00:00
The above example works when you're directly working on
`pkgs/top-level/python-packages.nix` in the Nixpkgs repository. Often though,
2017-08-26 09:21:30 +00:00
you will want to test a Nix expression outside of the Nixpkgs tree.
2016-02-21 19:13:44 +00:00
2017-08-26 09:21:30 +00:00
The following expression creates a derivation for the `toolz` package,
and adds it along with a `numpy` package to a Python environment.
2016-02-21 19:13:44 +00:00
```nix
with import < nixpkgs > {};
( let
2017-08-26 09:21:30 +00:00
my_toolz = python35.pkgs.buildPythonPackage rec {
pname = "toolz";
version = "0.7.4";
src = python35.pkgs.fetchPypi {
inherit pname version;
sha256 = "43c2c9e5e7a16b6c88ba3088a9bfc82f7db8e13378be7c78d6c14a5f8ed05afd";
2016-02-21 19:13:44 +00:00
};
2016-12-21 14:44:50 +00:00
doCheck = false;
2016-02-21 19:13:44 +00:00
meta = {
2018-06-27 20:12:57 +00:00
homepage = "https://github.com/pytoolz/toolz/";
2016-02-21 19:13:44 +00:00
description = "List processing tools and functional utilities";
};
};
2017-08-26 09:21:30 +00:00
in python35.withPackages (ps: [ps.numpy my_toolz])
2016-02-21 19:13:44 +00:00
).env
```
2017-08-26 09:21:30 +00:00
Executing `nix-shell` will result in an environment in which you can use
Python 3.5 and the `toolz` package. As you can see we had to explicitly mention
for which Python version we want to build a package.
2016-02-21 19:13:44 +00:00
2017-08-26 09:21:30 +00:00
So, what did we do here? Well, we took the Nix expression that we used earlier
to build a Python environment, and said that we wanted to include our own
version of `toolz` , named `my_toolz` . To introduce our own package in the scope
of `withPackages` we used a `let` expression. You can see that we used
`ps.numpy` to select numpy from the nixpkgs package set (`ps`). We did not take
`toolz` from the Nixpkgs package set this time, but instead took our own version
that we introduced with the `let` expression.
2016-02-21 19:13:44 +00:00
2017-08-26 09:21:30 +00:00
#### Handling dependencies
2016-02-21 19:13:44 +00:00
2018-10-10 00:42:29 +00:00
Our example, `toolz` , does not have any dependencies on other Python packages or
system libraries. According to the manual, `buildPythonPackage` uses the
arguments `buildInputs` and `propagatedBuildInputs` to specify dependencies. If
something is exclusively a build-time dependency, then the dependency should be
included as a `buildInput` , but if it is (also) a runtime dependency, then it
should be added to `propagatedBuildInputs` . Test dependencies are considered
build-time dependencies and passed to `checkInputs` .
2016-02-21 19:13:44 +00:00
The following example shows which arguments are given to `buildPythonPackage` in
order to build [`datashape` ](https://github.com/blaze/datashape ).
```nix
2019-03-24 09:29:53 +00:00
{ lib, buildPythonPackage, fetchPypi, numpy, multipledispatch, dateutil, pytest }:
2016-02-21 19:13:44 +00:00
2019-03-23 02:50:30 +00:00
buildPythonPackage rec {
pname = "datashape";
version = "0.4.7";
2016-02-21 19:13:44 +00:00
2019-03-23 02:50:30 +00:00
src = fetchPypi {
inherit pname version;
sha256 = "14b2ef766d4c9652ab813182e866f493475e65e558bed0822e38bf07bba1a278";
};
2016-02-21 19:13:44 +00:00
2019-03-23 02:50:30 +00:00
checkInputs = [ pytest ];
propagatedBuildInputs = [ numpy multipledispatch dateutil ];
2017-03-05 16:16:29 +00:00
2019-03-23 02:50:30 +00:00
meta = with lib; {
homepage = https://github.com/ContinuumIO/datashape;
description = "A data description language";
license = licenses.bsd2;
maintainers = with maintainers; [ fridh ];
2016-02-21 19:13:44 +00:00
};
2017-03-05 16:16:29 +00:00
}
2016-02-21 19:13:44 +00:00
```
We can see several runtime dependencies, `numpy` , `multipledispatch` , and
2019-03-23 02:50:30 +00:00
`dateutil` . Furthermore, we have one `checkInputs` , i.e. `pytest` . `pytest` is a
2016-02-21 19:13:44 +00:00
test runner and is only used during the `checkPhase` and is therefore not added
to `propagatedBuildInputs` .
In the previous case we had only dependencies on other Python packages to consider.
Occasionally you have also system libraries to consider. E.g., `lxml` provides
Python bindings to `libxml2` and `libxslt` . These libraries are only required
when building the bindings and are therefore added as `buildInputs` .
```nix
2019-03-24 09:29:53 +00:00
{ lib, pkgs, buildPythonPackage, fetchPypi }:
2016-02-21 19:13:44 +00:00
2019-03-23 02:50:30 +00:00
buildPythonPackage rec {
pname = "lxml";
version = "3.4.4";
2016-02-21 19:13:44 +00:00
2019-03-23 02:50:30 +00:00
src = fetchPypi {
inherit pname version;
sha256 = "16a0fa97hym9ysdk3rmqz32xdjqmy4w34ld3rm3jf5viqjx65lxk";
};
2016-02-21 19:13:44 +00:00
2019-03-23 02:50:30 +00:00
buildInputs = [ pkgs.libxml2 pkgs.libxslt ];
2017-03-05 16:16:29 +00:00
2019-03-23 02:50:30 +00:00
meta = with lib; {
description = "Pythonic binding for the libxml2 and libxslt libraries";
homepage = https://lxml.de;
license = licenses.bsd3;
maintainers = with maintainers; [ sjourdois ];
2016-02-21 19:13:44 +00:00
};
2017-03-05 16:16:29 +00:00
}
2016-02-21 19:13:44 +00:00
```
In this example `lxml` and Nix are able to work out exactly where the relevant
files of the dependencies are. This is not always the case.
The example below shows bindings to The Fastest Fourier Transform in the West, commonly known as
FFTW. On Nix we have separate packages of FFTW for the different types of floats
(`"single"`, `"double"` , `"long-double"` ). The bindings need all three types,
and therefore we add all three as `buildInputs` . The bindings don't expect to
find each of them in a different folder, and therefore we have to set `LDFLAGS`
and `CFLAGS` .
```nix
2019-03-24 09:29:53 +00:00
{ lib, pkgs, buildPythonPackage, fetchPypi, numpy, scipy }:
2016-02-21 19:13:44 +00:00
2019-03-23 02:50:30 +00:00
buildPythonPackage rec {
pname = "pyFFTW";
version = "0.9.2";
2016-02-21 19:13:44 +00:00
2019-03-23 02:50:30 +00:00
src = fetchPypi {
inherit pname version;
sha256 = "f6bbb6afa93085409ab24885a1a3cdb8909f095a142f4d49e346f2bd1b789074";
};
2016-02-21 19:13:44 +00:00
2019-03-23 02:50:30 +00:00
buildInputs = [ pkgs.fftw pkgs.fftwFloat pkgs.fftwLongDouble];
2016-02-21 19:13:44 +00:00
2019-03-23 02:50:30 +00:00
propagatedBuildInputs = [ numpy scipy ];
2016-02-21 19:13:44 +00:00
2019-03-23 02:50:30 +00:00
# Tests cannot import pyfftw. pyfftw works fine though.
doCheck = false;
2016-02-21 19:13:44 +00:00
2019-03-23 02:50:30 +00:00
preConfigure = ''
export LDFLAGS="-L${pkgs.fftw.dev}/lib -L${pkgs.fftwFloat.out}/lib -L${pkgs.fftwLongDouble.out}/lib"
export CFLAGS="-I${pkgs.fftw.dev}/include -I${pkgs.fftwFloat.dev}/include -I${pkgs.fftwLongDouble.dev}/include"
2019-03-24 09:29:53 +00:00
'';
2017-03-05 16:16:29 +00:00
2019-03-23 02:50:30 +00:00
meta = with lib; {
description = "A pythonic wrapper around FFTW, the FFT library, presenting a unified interface for all the supported transforms";
homepage = http://hgomersall.github.com/pyFFTW;
license = with licenses; [ bsd2 bsd3 ];
maintainers = with maintainers; [ fridh ];
2016-02-21 19:13:44 +00:00
};
2017-03-05 16:16:29 +00:00
}
2016-02-21 19:13:44 +00:00
```
Note also the line `doCheck = false;` , we explicitly disabled running the test-suite.
#### Develop local package
2016-12-21 14:44:50 +00:00
As a Python developer you're likely aware of [development mode ](http://setuptools.readthedocs.io/en/latest/setuptools.html#development-mode ) (`python setup.py develop`);
2016-02-21 19:13:44 +00:00
instead of installing the package this command creates a special link to the project code.
That way, you can run updated code without having to reinstall after each and every change you make.
2016-12-21 14:44:50 +00:00
Development mode is also available. Let's see how you can use it.
2016-02-21 19:13:44 +00:00
In the previous Nix expression the source was fetched from an url. We can also refer to a local source instead using
2017-03-05 16:16:29 +00:00
`src = ./path/to/source/tree;`
2016-02-21 19:13:44 +00:00
If we create a `shell.nix` file which calls `buildPythonPackage` , and if `src`
is a local source, and if the local source has a `setup.py` , then development
mode is activated.
In the following example we create a simple environment that
has a Python 3.5 version of our package in it, as well as its dependencies and
other packages we like to have in the environment, all specified with `propagatedBuildInputs` .
Indeed, we can just add any package we like to have in our environment to `propagatedBuildInputs` .
```nix
2017-08-06 08:18:36 +00:00
with import < nixpkgs > {};
2019-03-23 02:50:30 +00:00
with python35Packages;
2016-02-21 19:13:44 +00:00
buildPythonPackage rec {
name = "mypackage";
src = ./path/to/package/source;
propagatedBuildInputs = [ pytest numpy pkgs.libsndfile ];
2017-03-05 16:16:29 +00:00
}
2016-02-21 19:13:44 +00:00
```
It is important to note that due to how development mode is implemented on Nix it is not possible to have multiple packages simultaneously in development mode.
### Organising your packages
So far we discussed how you can use Python on Nix, and how you can develop with
it. We've looked at how you write expressions to package Python packages, and we
looked at how you can create environments in which specified packages are
available.
At some point you'll likely have multiple packages which you would
like to be able to use in different projects. In order to minimise unnecessary
2018-07-26 12:19:45 +00:00
duplication we now look at how you can maintain a repository with your
2016-02-21 19:13:44 +00:00
own packages. The important functions here are `import` and `callPackage` .
### Including a derivation using `callPackage`
2016-05-29 14:30:29 +00:00
Earlier we created a Python environment using `withPackages` , and included the
2016-02-21 19:13:44 +00:00
`toolz` package via a `let` expression.
Let's split the package definition from the environment definition.
We first create a function that builds `toolz` in `~/path/to/toolz/release.nix`
```nix
2019-03-24 09:33:07 +00:00
{ lib, buildPythonPackage }:
2016-02-21 19:13:44 +00:00
buildPythonPackage rec {
2018-01-16 16:59:30 +00:00
pname = "toolz";
2016-02-21 19:13:44 +00:00
version = "0.7.4";
2018-01-16 16:59:30 +00:00
src = fetchPypi {
inherit pname version;
2016-02-21 19:13:44 +00:00
sha256 = "43c2c9e5e7a16b6c88ba3088a9bfc82f7db8e13378be7c78d6c14a5f8ed05afd";
};
2018-07-03 15:19:18 +00:00
meta = with lib; {
2019-04-22 08:14:28 +00:00
homepage = "https://github.com/pytoolz/toolz/";
2016-02-21 19:13:44 +00:00
description = "List processing tools and functional utilities";
license = licenses.bsd3;
maintainers = with maintainers; [ fridh ];
};
2017-03-05 16:16:29 +00:00
}
2016-02-21 19:13:44 +00:00
```
2019-03-24 09:33:07 +00:00
It takes an argument `buildPythonPackage` .
2016-02-21 19:13:44 +00:00
We now call this function using `callPackage` in the definition of our environment
```nix
with import < nixpkgs > {};
( let
2019-03-24 09:33:07 +00:00
toolz = callPackage /path/to/toolz/release.nix {
buildPythonPackage = python35Packages.buildPythonPackage;
2017-03-05 16:16:29 +00:00
};
2019-03-24 09:33:07 +00:00
in python35.withPackages (ps: [ ps.numpy toolz ])
2016-02-21 19:13:44 +00:00
).env
```
Important to remember is that the Python version for which the package is made
depends on the `python` derivation that is passed to `buildPythonPackage` . Nix
tries to automatically pass arguments when possible, which is why generally you
don't explicitly define which `python` derivation should be used. In the above
example we use `buildPythonPackage` that is part of the set `python35Packages` ,
and in this case the `python35` interpreter is automatically used.
## Reference
### Interpreters
2020-01-04 14:27:03 +00:00
Versions 2.7, 3.5, 3.6, 3.7 and 3.8 of the CPython interpreter are available as
respectively `python27` , `python35` , `python36` , `python37` and `python38` . The aliases
2018-05-15 05:46:47 +00:00
`python2` and `python3` correspond to respectively `python27` and
`python37` . The default interpreter, `python` , maps to `python2` . The PyPy
interpreters compatible with Python 2.7 and 3 are available as `pypy27` and
`pypy3` , with aliases `pypy2` mapping to `pypy27` and `pypy` mapping to
`pypy2` . The Nix expressions for the interpreters can be
2018-11-10 10:08:54 +00:00
found in `pkgs/development/interpreters/python` .
2016-02-21 19:13:44 +00:00
All packages depending on any Python interpreter get appended
`out/{python.sitePackages}` to `$PYTHONPATH` if such directory
exists.
2016-10-10 07:54:29 +00:00
#### Missing `tkinter` module standard library
2016-10-14 15:49:51 +00:00
To reduce closure size the `Tkinter` /`tkinter` is available as a separate package, `pythonPackages.tkinter` .
2016-10-10 07:54:29 +00:00
2016-02-21 19:13:44 +00:00
#### Attributes on interpreters packages
Each interpreter has the following attributes:
- `libPrefix` . Name of the folder in `${python}/lib/` for corresponding interpreter.
- `interpreter` . Alias for `${python}/bin/${executable}` .
- `buildEnv` . Function to build python interpreter environments with extra packages bundled together. See section *python.buildEnv function* for usage and documentation.
2016-05-29 14:30:29 +00:00
- `withPackages` . Simpler interface to `buildEnv` . See section *python.withPackages function* for usage and documentation.
2016-02-21 19:13:44 +00:00
- `sitePackages` . Alias for `lib/${libPrefix}/site-packages` .
2018-11-04 07:17:31 +00:00
- `executable` . Name of the interpreter executable, e.g. `python3.7` .
2016-12-04 10:55:25 +00:00
- `pkgs` . Set of Python packages for that specific interpreter. The package set can be modified by overriding the interpreter and passing `packageOverrides` .
2016-02-21 19:13:44 +00:00
### Building packages and applications
2016-12-04 09:16:14 +00:00
Python libraries and applications that use `setuptools` or
2019-04-23 09:37:10 +00:00
`distutils` are typically built with respectively the `buildPythonPackage` and
2016-12-04 09:16:14 +00:00
`buildPythonApplication` functions. These two functions also support installing a `wheel` .
2016-02-21 19:13:44 +00:00
All Python packages reside in `pkgs/top-level/python-packages.nix` and all
2016-12-04 09:16:14 +00:00
applications elsewhere. In case a package is used as both a library and an application,
then the package should be in `pkgs/top-level/python-packages.nix` since only those packages are made
available for all interpreter versions. The preferred location for library expressions is in
2016-02-21 19:13:44 +00:00
`pkgs/development/python-modules` . It is important that these packages are
2016-12-04 09:16:14 +00:00
called from `pkgs/top-level/python-packages.nix` and not elsewhere, to guarantee
2016-02-21 19:13:44 +00:00
the right version of the package is built.
Based on the packages defined in `pkgs/top-level/python-packages.nix` an
attribute set is created for each available Python interpreter. The available
sets are
* `pkgs.python27Packages`
* `pkgs.python35Packages`
2017-03-21 09:42:58 +00:00
* `pkgs.python36Packages`
2018-01-24 15:10:08 +00:00
* `pkgs.python37Packages`
2016-02-21 19:13:44 +00:00
* `pkgs.pypyPackages`
and the aliases
2016-10-18 08:29:22 +00:00
* `pkgs.python2Packages` pointing to `pkgs.python27Packages`
2018-10-21 07:05:43 +00:00
* `pkgs.python3Packages` pointing to `pkgs.python37Packages`
2016-12-04 09:16:14 +00:00
* `pkgs.pythonPackages` pointing to `pkgs.python2Packages`
2016-02-21 19:13:44 +00:00
#### `buildPythonPackage` function
The `buildPythonPackage` function is implemented in
2019-07-17 18:36:47 +00:00
`pkgs/development/interpreters/python/mk-python-derivation`
using setup hooks.
2016-02-21 19:13:44 +00:00
2016-12-04 09:16:14 +00:00
The following is an example:
2017-03-05 16:16:29 +00:00
```nix
2018-10-10 00:42:29 +00:00
{ lib, buildPythonPackage, fetchPypi, hypothesis, setuptools_scm, attrs, py, setuptools, six, pluggy }:
2016-02-21 19:13:44 +00:00
2018-01-16 16:59:30 +00:00
buildPythonPackage rec {
pname = "pytest";
2018-10-10 00:42:29 +00:00
version = "3.3.1";
2016-02-21 19:13:44 +00:00
2018-01-16 16:59:30 +00:00
src = fetchPypi {
inherit pname version;
sha256 = "cf8436dc59d8695346fcd3ab296de46425ecab00d64096cebe79fb51ecb2eb93";
};
2016-02-21 19:13:44 +00:00
2018-10-11 20:18:33 +00:00
postPatch = ''
2018-10-10 00:42:29 +00:00
# don't test bash builtins
rm testing/test_argcomplete.py
'';
2018-01-16 16:59:30 +00:00
checkInputs = [ hypothesis ];
2019-03-23 02:50:30 +00:00
nativeBuildInputs = [ setuptools_scm ];
2018-01-16 16:59:30 +00:00
propagatedBuildInputs = [ attrs py setuptools six pluggy ];
2018-10-10 00:42:29 +00:00
meta = with lib; {
2018-01-16 16:59:30 +00:00
maintainers = with maintainers; [ domenkozar lovek323 madjar lsix ];
description = "Framework for writing tests";
2017-03-05 16:16:29 +00:00
};
}
```
2016-02-21 19:13:44 +00:00
The `buildPythonPackage` mainly does four things:
2016-08-15 09:35:32 +00:00
* In the `buildPhase` , it calls `${python.interpreter} setup.py bdist_wheel` to
build a wheel binary zipfile.
2016-02-21 19:13:44 +00:00
* In the `installPhase` , it installs the wheel file using `pip install *.whl` .
2016-08-15 09:35:32 +00:00
* In the `postFixup` phase, the `wrapPythonPrograms` bash function is called to
wrap all programs in the `$out/bin/*` directory to include `$PATH`
environment variable and add dependent libraries to script's `sys.path` .
2016-02-21 19:13:44 +00:00
* In the `installCheck` phase, `${python.interpreter} setup.py test` is ran.
By default tests are run because `doCheck = true` . Test dependencies, like
2018-05-30 17:07:02 +00:00
e.g. the test runner, should be added to `checkInputs` .
2016-02-21 19:13:44 +00:00
By default `meta.platforms` is set to the same value
2017-09-01 17:38:07 +00:00
as the interpreter unless overridden otherwise.
2016-02-21 19:13:44 +00:00
##### `buildPythonPackage` parameters
2018-05-30 17:07:02 +00:00
All parameters from `stdenv.mkDerivation` function are still supported. The following are specific to `buildPythonPackage` :
* `catchConflicts ? true` : If `true` , abort package build if a package name appears more than once in dependency tree. Default is `true` .
2019-10-24 00:50:28 +00:00
* `disabled` ? false: If `true` , package is not built for the particular Python interpreter version.
2018-05-30 17:07:02 +00:00
* `dontWrapPythonPrograms ? false` : Skip wrapping of python programs.
2019-05-15 06:28:00 +00:00
* `permitUserSite ? false` : Skip setting the `PYTHONNOUSERSITE` environment variable in wrapped programs.
2019-01-05 09:26:57 +00:00
* `installFlags ? []` : A list of strings. Arguments to be passed to `pip install` . To pass options to `python setup.py install` , use `--install-option` . E.g., `installFlags=["--install-option='--cpp_implementation'"]` .
2019-02-17 19:33:30 +00:00
* `format ? "setuptools"` : Format of the source. Valid options are `"setuptools"` , `"pyproject"` , `"flit"` , `"wheel"` , and `"other"` . `"setuptools"` is for when the source has a `setup.py` and `setuptools` is used to build a wheel, `flit` , in case `flit` should be used to build a wheel, and `wheel` in case a wheel is provided. Use `other` when a custom `buildPhase` and/or `installPhase` is needed.
2018-05-30 17:07:02 +00:00
* `makeWrapperArgs ? []` : A list of strings. Arguments to be passed to `makeWrapper` , which wraps generated binaries. By default, the arguments to `makeWrapper` set `PATH` and `PYTHONPATH` environment variables before calling the binary. Additional arguments here can allow a developer to set environment variables which will be available when the binary is run. For example, `makeWrapperArgs = ["--set FOO BAR" "--set BAZ QUX"]` .
* `namePrefix` : Prepends text to `${name}` parameter. In case of libraries, this defaults to `"python3.5-"` for Python 3.5, etc., and in case of applications to `""` .
* `pythonPath ? []` : List of packages to be added into `$PYTHONPATH` . Packages in `pythonPath` are not propagated (contrary to `propagatedBuildInputs` ).
2016-02-21 19:13:44 +00:00
* `preShellHook` : Hook to execute commands before `shellHook` .
* `postShellHook` : Hook to execute commands after `shellHook` .
2018-05-30 17:07:02 +00:00
* `removeBinByteCode ? true` : Remove bytecode from `/bin` . Bytecode is only created when the filenames end with `.py` .
2019-07-13 11:26:39 +00:00
* `setupPyGlobalFlags ? []` : List of flags passed to `setup.py` command.
2018-05-30 17:07:02 +00:00
* `setupPyBuildFlags ? []` : List of flags passed to `setup.py build_ext` command.
2016-02-21 19:13:44 +00:00
2019-01-05 09:26:57 +00:00
The `stdenv.mkDerivation` function accepts various parameters for describing build inputs (see "Specifying dependencies"). The following are of special
interest for Python packages, either because these are primarily used, or because their behaviour is different:
* `nativeBuildInputs ? []` : Build-time only dependencies. Typically executables as well as the items listed in `setup_requires` .
* `buildInputs ? []` : Build and/or run-time dependencies that need to be be compiled for the host machine. Typically non-Python libraries which are being linked.
* `checkInputs ? []` : Dependencies needed for running the `checkPhase` . These are added to `nativeBuildInputs` when `doCheck = true` . Items listed in `tests_require` go here.
* `propagatedBuildInputs ? []` : Aside from propagating dependencies, `buildPythonPackage` also injects code into and wraps executables with the paths included in this list. Items listed in `install_requires` go here.
2017-03-21 09:08:10 +00:00
##### Overriding Python packages
2017-08-12 06:58:06 +00:00
The `buildPythonPackage` function has a `overridePythonAttrs` method that
2017-03-21 09:08:10 +00:00
can be used to override the package. In the following example we create an
environment where we have the `blaze` package using an older version of `pandas` .
We override first the Python interpreter and pass
`packageOverrides` which contains the overrides for packages in the package set.
```nix
with import < nixpkgs > {};
(let
python = let
packageOverrides = self: super: {
2017-08-12 06:58:06 +00:00
pandas = super.pandas.overridePythonAttrs(old: rec {
2017-03-21 09:08:10 +00:00
version = "0.19.1";
src = super.fetchPypi {
pname = "pandas";
inherit version;
sha256 = "08blshqj9zj1wyjhhw3kl2vas75vhhicvv72flvf1z3jvapgw295";
};
});
};
2019-07-05 11:55:45 +00:00
in pkgs.python3.override {inherit packageOverrides; self = python;};
2017-03-21 09:08:10 +00:00
in python.withPackages(ps: [ps.blaze])).env
```
2016-02-21 19:13:44 +00:00
#### `buildPythonApplication` function
2018-08-26 07:31:39 +00:00
The `buildPythonApplication` function is practically the same as
`buildPythonPackage` . The main purpose of this function is to build a Python
package where one is interested only in the executables, and not importable
modules. For that reason, when adding this package to a `python.buildEnv` , the
modules won't be made available.
Another difference is that `buildPythonPackage` by default prefixes the names of
the packages with the version of the interpreter. Because this is irrelevant for
applications, the prefix is omitted.
2016-02-21 19:13:44 +00:00
2018-10-10 00:42:29 +00:00
When packaging a python application with `buildPythonApplication` , it should be
2018-10-11 20:18:33 +00:00
called with `callPackage` and passed `python` or `pythonPackages` (possibly
specifying an interpreter version), like this:
```nix
{ lib, python3Packages }:
python3Packages.buildPythonApplication rec {
pname = "luigi";
version = "2.7.9";
src = python3Packages.fetchPypi {
inherit pname version;
sha256 = "035w8gqql36zlan0xjrzz9j4lh9hs0qrsgnbyw07qs7lnkvbdv9x";
};
2018-10-05 01:51:46 +00:00
propagatedBuildInputs = with python3Packages; [ tornado_4 python-daemon ];
2018-10-11 20:18:33 +00:00
meta = with lib; {
...
};
}
```
This is then added to `all-packages.nix` just as any other application would be.
```nix
luigi = callPackage ../applications/networking/cluster/luigi { };
```
Since the package is an application, a consumer doesn't need to care about
python versions or modules, which is why they don't go in `pythonPackages` .
2018-10-10 00:42:29 +00:00
2018-05-30 17:07:02 +00:00
#### `toPythonApplication` function
A distinction is made between applications and libraries, however, sometimes a
package is used as both. In this case the package is added as a library to
`python-packages.nix` and as an application to `all-packages.nix` . To reduce
duplication the `toPythonApplication` can be used to convert a library to an
application.
The Nix expression shall use `buildPythonPackage` and be called from
`python-packages.nix` . A reference shall be created from `all-packages.nix` to
the attribute in `python-packages.nix` , and the `toPythonApplication` shall be
applied to the reference:
```nix
youtube-dl = with pythonPackages; toPythonApplication youtube-dl;
```
#### `toPythonModule` function
In some cases, such as bindings, a package is created using
`stdenv.mkDerivation` and added as attribute in `all-packages.nix` .
The Python bindings should be made available from `python-packages.nix` .
The `toPythonModule` function takes a derivation and makes certain Python-specific modifications.
```nix
opencv = toPythonModule (pkgs.opencv.override {
enablePython = true;
pythonPackages = self;
});
```
Do pay attention to passing in the right Python version!
#### `python.buildEnv` function
2016-02-21 19:13:44 +00:00
Python environments can be created using the low-level `pkgs.buildEnv` function.
This example shows how to create an environment that has the Pyramid Web Framework.
Saving the following as `default.nix`
2017-03-05 16:16:29 +00:00
```nix
with import < nixpkgs > {};
2016-02-21 19:13:44 +00:00
2017-03-05 16:16:29 +00:00
python.buildEnv.override {
2019-03-23 02:50:30 +00:00
extraLibs = [ pythonPackages.pyramid ];
2017-03-05 16:16:29 +00:00
ignoreCollisions = true;
}
```
2016-02-21 19:13:44 +00:00
and running `nix-build` will create
2017-03-05 16:16:29 +00:00
```
/nix/store/cf1xhjwzmdki7fasgr4kz6di72ykicl5-python-2.7.8-env
```
2016-02-21 19:13:44 +00:00
with wrapped binaries in `bin/` .
You can also use the `env` attribute to create local environments with needed
packages installed. This is somewhat comparable to `virtualenv` . For example,
running `nix-shell` with the following `shell.nix`
2017-03-05 16:16:29 +00:00
```nix
with import < nixpkgs > {};
2016-02-21 19:13:44 +00:00
2017-03-05 16:16:29 +00:00
(python3.buildEnv.override {
2017-05-07 10:55:45 +00:00
extraLibs = with python3Packages; [ numpy requests ];
2017-03-05 16:16:29 +00:00
}).env
```
2016-02-21 19:13:44 +00:00
will drop you into a shell where Python will have the
specified packages in its path.
##### `python.buildEnv` arguments
* `extraLibs` : List of packages installed inside the environment.
* `postBuild` : Shell command executed after the build of environment.
* `ignoreCollisions` : Ignore file collisions inside the environment (default is `false` ).
2019-05-15 06:28:00 +00:00
* `permitUserSite` : Skip setting the `PYTHONNOUSERSITE` environment variable in wrapped binaries in the environment.
2016-02-21 19:13:44 +00:00
2018-05-30 17:07:02 +00:00
#### `python.withPackages` function
2016-05-29 14:08:27 +00:00
The `python.withPackages` function provides a simpler interface to the `python.buildEnv` functionality.
2017-03-05 00:00:02 +00:00
It takes a function as an argument that is passed the set of python packages and returns the list
2016-05-29 14:08:27 +00:00
of the packages to be included in the environment. Using the `withPackages` function, the previous
example for the Pyramid Web Framework environment can be written like this:
2017-03-05 16:16:29 +00:00
```nix
with import < nixpkgs > {};
2016-05-29 14:08:27 +00:00
2017-03-05 16:16:29 +00:00
python.withPackages (ps: [ps.pyramid])
```
2016-05-29 14:08:27 +00:00
2017-03-05 00:00:02 +00:00
`withPackages` passes the correct package set for the specific interpreter version as an
2016-05-29 14:08:27 +00:00
argument to the function. In the above example, `ps` equals `pythonPackages` .
But you can also easily switch to using python3:
2017-03-05 16:16:29 +00:00
```nix
with import < nixpkgs > {};
2017-03-05 00:00:02 +00:00
2017-03-05 16:16:29 +00:00
python3.withPackages (ps: [ps.pyramid])
```
2016-05-29 14:08:27 +00:00
Now, `ps` is set to `python3Packages` , matching the version of the interpreter.
As `python.withPackages` simply uses `python.buildEnv` under the hood, it also supports the `env`
attribute. The `shell.nix` file from the previous section can thus be also written like this:
2017-03-05 16:16:29 +00:00
```nix
with import < nixpkgs > {};
2016-05-29 14:08:27 +00:00
2017-07-29 18:49:24 +00:00
(python36.withPackages (ps: [ps.numpy ps.requests])).env
2017-03-05 16:16:29 +00:00
```
2016-05-29 14:08:27 +00:00
In contrast to `python.buildEnv` , `python.withPackages` does not support the more advanced options
such as `ignoreCollisions = true` or `postBuild` . If you need them, you have to use `python.buildEnv` .
2018-05-30 17:07:02 +00:00
Python 2 namespace packages may provide `__init__.py` that collide. In that case `python.buildEnv`
2017-04-18 07:05:00 +00:00
should be used with `ignoreCollisions = true` .
2019-07-17 18:36:47 +00:00
#### Setup hooks
The following are setup hooks specifically for Python packages. Most of these are
used in `buildPythonPackage` .
- `flitBuildHook` to build a wheel using `flit` .
- `pipBuildHook` to build a wheel using `pip` and PEP 517. Note a build system (e.g. `setuptools` or `flit` ) should still be added as `nativeBuildInput` .
- `pipInstallHook` to install wheels.
- `pytestCheckHook` to run tests with `pytest` .
- `pythonCatchConflictsHook` to check whether a Python package is not already existing.
- `pythonImportsCheckHook` to check whether importing the listed modules works.
- `pythonRemoveBinBytecode` to remove bytecode from the `/bin` folder.
- `setuptoolsBuildHook` to build a wheel using `setuptools` .
- `setuptoolsCheckHook` to run tests with `python setup.py test` .
- `wheelUnpackHook` to move a wheel to the correct folder so it can be installed with the `pipInstallHook` .
2016-02-21 19:13:44 +00:00
### Development mode
Development or editable mode is supported. To develop Python packages
`buildPythonPackage` has additional logic inside `shellPhase` to run `pip
install -e . --prefix $TMPDIR/`for the package.
Warning: `shellPhase` is executed only if `setup.py` exists.
Given a `default.nix` :
2017-03-05 16:16:29 +00:00
```nix
with import < nixpkgs > {};
2016-02-21 19:13:44 +00:00
2019-03-23 02:50:30 +00:00
pythonPackages.buildPythonPackage {
name = "myproject";
buildInputs = with pythonPackages; [ pyramid ];
2016-02-21 19:13:44 +00:00
2019-03-23 02:50:30 +00:00
src = ./.;
}
2017-03-05 16:16:29 +00:00
```
2016-02-21 19:13:44 +00:00
Running `nix-shell` with no arguments should give you
2016-04-06 16:16:23 +00:00
the environment in which the package would be built with
2016-02-21 19:13:44 +00:00
`nix-build` .
Shortcut to setup environments with C headers/libraries and python packages:
2017-03-05 16:16:29 +00:00
```shell
nix-shell -p pythonPackages.pyramid zlib libjpeg git
```
2016-02-21 19:13:44 +00:00
Note: There is a boolean value `lib.inNixShell` set to `true` if nix-shell is invoked.
### Tools
Packages inside nixpkgs are written by hand. However many tools exist in
community to help save time. No tool is preferred at the moment.
2019-10-14 08:54:01 +00:00
- [pypi2nix ](https://github.com/nix-community/pypi2nix ): Generate Nix expressions for your Python project. Note that [sharing derivations from pypi2nix with nixpkgs is possible but not encouraged ](https://github.com/nix-community/pypi2nix/issues/222#issuecomment-443497376 ).
- [python2nix ](https://github.com/proger/python2nix ) by Vladimir Kirillov.
2016-02-21 19:13:44 +00:00
2017-02-22 14:55:58 +00:00
### Deterministic builds
2018-11-04 07:17:31 +00:00
The Python interpreters are now built deterministically.
2017-02-22 14:55:58 +00:00
Minor modifications had to be made to the interpreters in order to generate
deterministic bytecode. This has security implications and is relevant for
those using Python in a `nix-shell` .
When the environment variable `DETERMINISTIC_BUILD` is set, all bytecode will have timestamp 1.
2017-03-21 09:42:58 +00:00
The `buildPythonPackage` function sets `DETERMINISTIC_BUILD=1` and
[PYTHONHASHSEED=0 ](https://docs.python.org/3.5/using/cmdline.html#envvar-PYTHONHASHSEED ).
2017-02-22 14:55:58 +00:00
Both are also exported in `nix-shell` .
2017-09-02 10:06:37 +00:00
### Automatic tests
It is recommended to test packages as part of the build process.
Source distributions (`sdist`) often include test files, but not always.
By default the command `python setup.py test` is run as part of the
`checkPhase` , but often it is necessary to pass a custom `checkPhase` . An
example of such a situation is when `py.test` is used.
#### Common issues
2017-09-25 13:00:47 +00:00
- Non-working tests can often be deselected. By default `buildPythonPackage` runs `python setup.py test` .
Most python modules follows the standard test protocol where the pytest runner can be used instead.
2018-05-30 17:07:02 +00:00
`py.test` supports a `-k` parameter to ignore test methods or classes:
2017-09-25 13:00:47 +00:00
```nix
buildPythonPackage {
# ...
# assumes the tests are located in tests
checkInputs = [ pytest ];
checkPhase = ''
py.test -k 'not function_name and not other_function' tests
'';
}
```
2017-09-02 10:06:37 +00:00
- Tests that attempt to access `$HOME` can be fixed by using the following work-around before running tests (e.g. `preCheck` ): `export HOME=$(mktemp -d)`
2016-02-21 19:13:44 +00:00
## FAQ
### How to solve circular dependencies?
Consider the packages `A` and `B` that depend on each other. When packaging `B` ,
a solution is to override package `A` not to depend on `B` as an input. The same
should also be done when packaging `A` .
### How to override a Python package?
2016-12-04 10:55:25 +00:00
We can override the interpreter and pass `packageOverrides` .
In the following example we rename the `pandas` package and build it.
```nix
2016-02-21 19:13:44 +00:00
with import < nixpkgs > {};
2017-03-21 09:08:10 +00:00
(let
2016-12-04 10:55:25 +00:00
python = let
packageOverrides = self: super: {
2017-08-12 06:58:06 +00:00
pandas = super.pandas.overridePythonAttrs(old: {name="foo";});
2016-12-04 10:55:25 +00:00
};
in pkgs.python35.override {inherit packageOverrides;};
2016-02-21 19:13:44 +00:00
2017-03-21 09:08:10 +00:00
in python.withPackages(ps: [ps.pandas])).env
2016-02-21 19:13:44 +00:00
```
2017-03-21 09:08:10 +00:00
Using `nix-build` on this expression will build an environment that contains the
package `pandas` but with the new name `foo` .
2016-02-21 19:13:44 +00:00
2016-12-04 10:55:25 +00:00
All packages in the package set will use the renamed package.
A typical use case is to switch to another version of a certain package.
For example, in the Nixpkgs repository we have multiple versions of `django` and `scipy` .
In the following example we use a different version of `scipy` and create an environment that uses it.
All packages in the Python package set will now use the updated `scipy` version.
2016-02-21 19:13:44 +00:00
2016-12-04 10:55:25 +00:00
```nix
with import < nixpkgs > {};
2017-03-05 16:16:29 +00:00
( let
packageOverrides = self: super: {
scipy = super.scipy_0_17;
};
in (pkgs.python35.override {inherit packageOverrides;}).withPackages (ps: [ps.blaze])
2016-05-29 14:30:29 +00:00
).env
2016-02-21 19:13:44 +00:00
```
2016-12-04 10:55:25 +00:00
The requested package `blaze` depends on `pandas` which itself depends on `scipy` .
2016-02-21 19:13:44 +00:00
2016-12-17 18:05:21 +00:00
If you want the whole of Nixpkgs to use your modifications, then you can use `overlays`
2016-12-04 10:55:25 +00:00
as explained in this manual. In the following example we build a `inkscape` using a different version of `numpy` .
2017-03-05 16:16:29 +00:00
```nix
2016-12-04 10:55:25 +00:00
let
pkgs = import < nixpkgs > {};
2016-12-17 18:05:21 +00:00
newpkgs = import pkgs.path { overlays = [ (pkgsself: pkgssuper: {
2016-12-04 10:55:25 +00:00
python27 = let
packageOverrides = self: super: {
numpy = super.numpy_1_10;
};
in pkgssuper.python27.override {inherit packageOverrides;};
2016-12-17 18:05:21 +00:00
} ) ]; };
2016-12-04 10:55:25 +00:00
in newpkgs.inkscape
2016-08-30 15:06:17 +00:00
```
2016-08-13 12:18:59 +00:00
### `python setup.py bdist_wheel` cannot create .whl
2016-08-30 15:16:13 +00:00
Executing `python setup.py bdist_wheel` in a `nix-shell ` fails with
2016-08-13 12:18:59 +00:00
```
ValueError: ZIP does not support timestamps before 1980
```
2018-03-21 19:57:52 +00:00
This is because files from the Nix store (which have a timestamp of the UNIX epoch of January 1, 1970) are included in the .ZIP, but .ZIP archives follow the DOS convention of counting timestamps from 1980.
The command `bdist_wheel` reads the `SOURCE_DATE_EPOCH` environment variable, which `nix-shell` sets to 1. Unsetting this variable or giving it a value corresponding to 1980 or later enables building wheels.
2016-08-13 12:18:59 +00:00
Use 1980 as timestamp:
2017-03-05 16:16:29 +00:00
```shell
2016-08-30 15:16:13 +00:00
nix-shell --run "SOURCE_DATE_EPOCH=315532800 python3 setup.py bdist_wheel"
2016-08-13 12:18:59 +00:00
```
or the current time:
2017-03-05 16:16:29 +00:00
```shell
2016-08-30 15:16:13 +00:00
nix-shell --run "SOURCE_DATE_EPOCH=$(date +%s) python3 setup.py bdist_wheel"
2016-08-13 12:18:59 +00:00
```
2018-03-21 19:57:52 +00:00
or unset `SOURCE_DATE_EPOCH` :
2017-03-05 16:16:29 +00:00
```shell
2016-08-30 15:16:13 +00:00
nix-shell --run "unset SOURCE_DATE_EPOCH; python3 setup.py bdist_wheel"
2016-12-04 10:55:25 +00:00
```
2016-02-21 19:13:44 +00:00
### `install_data` / `data_files` problems
If you get the following error:
2017-03-05 16:16:29 +00:00
```
could not create '/nix/store/6l1bvljpy8gazlsw2aw9skwwp4pmvyxw-python-2.7.8/etc':
Permission denied
```
This is a [known bug ](https://github.com/pypa/setuptools/issues/130 ) in `setuptools` .
2016-02-21 19:13:44 +00:00
Setuptools `install_data` does not respect `--prefix` . An example of such package using the feature is `pkgs/tools/X11/xpra/default.nix` .
As workaround install it as an extra `preInstall` step:
2017-03-05 16:16:29 +00:00
```shell
${python.interpreter} setup.py install_data --install-dir=$out --root=$out
sed -i '/ = data\_files/d' setup.py
```
2016-02-21 19:13:44 +00:00
### Rationale of non-existent global site-packages
On most operating systems a global `site-packages` is maintained. This however
becomes problematic if you want to run multiple Python versions or have multiple
versions of certain libraries for your projects. Generally, you would solve such
issues by creating virtual environments using `virtualenv` .
On Nix each package has an isolated dependency tree which, in the case of
Python, guarantees the right versions of the interpreter and libraries or
packages are available. There is therefore no need to maintain a global `site-packages` .
If you want to create a Python environment for development, then the recommended
method is to use `nix-shell` , either with or without the `python.buildEnv`
function.
2017-01-12 16:00:50 +00:00
### How to consume python modules using pip in a virtualenv like I am used to on other Operating Systems ?
This is an example of a `default.nix` for a `nix-shell` , which allows to consume a `virtualenv` environment,
and install python modules through `pip` the traditional way.
Create this `default.nix` file, together with a `requirements.txt` and simply execute `nix-shell` .
2017-03-05 16:16:29 +00:00
```nix
2017-01-12 16:59:27 +00:00
with import < nixpkgs > {};
2019-12-17 14:26:06 +00:00
let
pythonPackages = python27Packages;
in
2017-01-12 16:00:50 +00:00
2017-03-05 00:00:02 +00:00
stdenv.mkDerivation {
2017-01-12 16:00:50 +00:00
name = "impurePythonEnv";
2019-03-23 02:50:30 +00:00
src = null;
2017-01-12 16:00:50 +00:00
buildInputs = [
2017-01-12 16:59:27 +00:00
# these packages are required for virtualenv and pip to work:
#
2019-12-17 14:26:06 +00:00
pythonPackages.virtualenv
pythonPackages.pip
2017-03-05 00:00:02 +00:00
# the following packages are related to the dependencies of your python
# project.
# In this particular example the python modules listed in the
2018-06-11 09:24:07 +00:00
# requirements.txt require the following packages to be installed locally
2017-01-12 16:59:27 +00:00
# in order to compile any binary extensions they may require.
#
2017-01-12 16:00:50 +00:00
taglib
openssl
git
libxml2
libxslt
libzip
2019-03-23 02:50:30 +00:00
zlib
];
2017-01-12 16:00:50 +00:00
shellHook = ''
2019-03-23 02:50:30 +00:00
# set SOURCE_DATE_EPOCH so that we can use python wheels
SOURCE_DATE_EPOCH=$(date +%s)
2019-12-17 14:26:06 +00:00
virtualenv --python=${pythonPackages.python.interpreter} --no-setuptools venv
2019-03-23 02:50:30 +00:00
export PATH=$PWD/venv/bin:$PATH
pip install -r requirements.txt
2017-01-12 16:00:50 +00:00
'';
}
```
2016-02-21 19:13:44 +00:00
2017-01-12 16:59:27 +00:00
Note that the `pip install` is an imperative action. So every time `nix-shell`
2017-03-05 00:00:02 +00:00
is executed it will attempt to download the python modules listed in
2017-01-12 16:59:27 +00:00
requirements.txt. However these will be cached locally within the `virtualenv`
folder and not downloaded again.
2017-03-20 23:06:51 +00:00
### How to override a Python package from `configuration.nix`?
If you need to change a package's attribute(s) from `configuration.nix` you could do:
```nix
2018-07-25 19:29:25 +00:00
nixpkgs.config.packageOverrides = super: {
python = super.python.override {
packageOverrides = python-self: python-super: {
2018-07-25 19:32:16 +00:00
zerobin = python-super.zerobin.overrideAttrs (oldAttrs: {
2018-07-25 19:29:25 +00:00
src = super.fetchgit {
2018-07-25 19:32:16 +00:00
url = "https://github.com/sametmax/0bin";
rev = "a344dbb18fe7a855d0742b9a1cede7ce423b34ec";
sha256 = "16d769kmnrpbdr0ph0whyf4yff5df6zi4kmwx7sz1d3r6c8p6xji";
2017-03-20 23:06:51 +00:00
};
});
};
};
};
```
2018-07-26 12:19:45 +00:00
`pythonPackages.zerobin` is now globally overridden. All packages and also the
2018-07-25 19:32:16 +00:00
`zerobin` NixOS service use the new definition.
2018-07-25 19:29:25 +00:00
Note that `python-super` refers to the old package set and `python-self`
to the new, overridden version.
To modify only a Python package set instead of a whole Python derivation, use this snippet:
```nix
myPythonPackages = pythonPackages.override {
overrides = self: super: {
2018-07-25 19:32:16 +00:00
zerobin = ...;
2018-07-25 19:29:25 +00:00
};
}
```
2016-02-21 19:13:44 +00:00
2017-06-10 10:18:10 +00:00
### How to override a Python package using overlays?
2018-07-25 19:29:25 +00:00
Use the following overlay template:
2017-06-10 10:18:10 +00:00
```nix
2018-10-18 19:00:48 +00:00
self: super: {
2017-06-10 10:18:10 +00:00
python = super.python.override {
packageOverrides = python-self: python-super: {
2018-07-25 19:32:16 +00:00
zerobin = python-super.zerobin.overrideAttrs (oldAttrs: {
src = super.fetchgit {
url = "https://github.com/sametmax/0bin";
rev = "a344dbb18fe7a855d0742b9a1cede7ce423b34ec";
sha256 = "16d769kmnrpbdr0ph0whyf4yff5df6zi4kmwx7sz1d3r6c8p6xji";
2017-06-10 10:18:10 +00:00
};
});
};
};
}
```
2018-10-18 19:00:48 +00:00
### How to use Intel's MKL with numpy and scipy?
A `site.cfg` is created that configures BLAS based on the `blas` parameter
of the `numpy` derivation. By passing in `mkl` , `numpy` and packages depending
on `numpy` will be built with `mkl` .
The following is an overlay that configures `numpy` to use `mkl` :
```nix
self: super: {
2018-10-23 21:33:49 +00:00
python37 = super.python37.override {
2018-10-18 19:00:48 +00:00
packageOverrides = python-self: python-super: {
numpy = python-super.numpy.override {
blas = super.pkgs.mkl;
};
};
};
}
```
2018-10-23 21:33:49 +00:00
`mkl` requires an `openmp` implementation when running with multiple processors.
By default, `mkl` will use Intel's `iomp` implementation if no other is
specified, but this is a runtime-only dependency and binary compatible with the
LLVM implementation. To use that one instead, Intel recommends users set it with
`LD_PRELOAD` .
Note that `mkl` is only available on `x86_64-{linux,darwin}` platforms;
moreover, Hydra is not building and distributing pre-compiled binaries using it.
2019-01-05 09:26:57 +00:00
### What inputs do `setup_requires`, `install_requires` and `tests_require` map to?
In a `setup.py` or `setup.cfg` it is common to declare dependencies:
* `setup_requires` corresponds to `nativeBuildInputs`
* `install_requires` corresponds to `propagatedBuildInputs`
* `tests_require` corresponds to `checkInputs`
2016-02-21 19:13:44 +00:00
## Contributing
### Contributing guidelines
Following rules are desired to be respected:
2017-09-02 10:06:37 +00:00
* Python libraries are called from `python-packages.nix` and packaged with `buildPythonPackage` . The expression of a library should be in `pkgs/development/python-modules/<name>/default.nix` . Libraries in `pkgs/top-level/python-packages.nix` are sorted quasi-alphabetically to avoid merge conflicts.
2017-02-22 12:38:02 +00:00
* Python applications live outside of `python-packages.nix` and are packaged with `buildPythonApplication` .
* Make sure libraries build for all Python interpreters.
* By default we enable tests. Make sure the tests are found and, in the case of libraries, are passing for all interpreters. If certain tests fail they can be disabled individually. Try to avoid disabling the tests altogether. In any case, when you disable tests, leave a comment explaining why.
2017-09-02 10:06:37 +00:00
* Commit names of Python libraries should reflect that they are Python libraries, so write for example `pythonPackages.numpy: 1.11 -> 1.12` .
2018-08-30 22:07:21 +00:00
* Attribute names in `python-packages.nix` should be normalized according to [PEP 0503 ](https://www.python.org/dev/peps/pep-0503/#normalized-names ).
2018-08-31 07:02:55 +00:00
This means that characters should be converted to lowercase and `.` and `_` should be replaced by a single `-` (foo-bar-baz instead of Foo__Bar.baz )