Restore more accurate history of the master branch

The first child is the proper master.
The second child is the proper staging.
The third child is FRidh work.
The forth child is the previous master at origin.

pkgs/applications/office/paperwork/backend.nix

···
 }:
 
 buildPythonPackage rec {
-  name = "paperwork-backend-${version}";
+  pname = "paperwork-backend";
   version = "1.2.1";
 
   src = fetchFromGitHub {

pkgs/build-support/setup-hooks/multiple-outputs.sh

···
 }
 
 # Make the "dev" propagate other outputs needed for development.
-# Note: with current cross-building setup, all packages are "native" if not cross-building;
-# however, if cross-building, the outputs are non-native. We have to choose the right file.
 _multioutPropagateDev() {
     if [ "$outputs" = "out" ]; then return; fi;
 
···
         return
     fi
 
-    local propagatedBuildInputsFile
-    if [ -z "$crossConfig" ]; then
-        propagatedBuildInputsFile=propagated-native-build-inputs
-    else
-        propagatedBuildInputsFile=propagated-build-inputs
-    fi
-
     mkdir -p "${!propagaterOutput}"/nix-support
     for output in $propagatedBuildOutputs; do
-        echo -n " ${!output}" >> "${!propagaterOutput}"/nix-support/$propagatedBuildInputsFile
+        echo -n " ${!output}" >> "${!propagaterOutput}"/nix-support/propagated-build-inputs
     done
 }
-

pkgs/build-support/trivial-builders.nix

···
         mkdir -p $out/nix-support
         cp ${script} $out/nix-support/setup-hook
       '' + lib.optionalString (deps != []) ''
-        printWords ${toString deps} > $out/nix-support/propagated-native-build-inputs
+        printWords ${toString deps} > $out/nix-support/propagated-build-inputs
       '' + lib.optionalString (substitutions != {}) ''
         substituteAll ${script} $out/nix-support/setup-hook
       '');

pkgs/data/misc/tzdata/default.nix

···
   postInstall =
     ''
       rm $out/share/zoneinfo-posix
-      ln -s . $out/share/zoneinfo/posix
+      mkdir $out/share/zoneinfo/posix
+      ( cd $out/share/zoneinfo/posix; ln -s ../* .; rm posix )
       mv $out/share/zoneinfo-leaps $out/share/zoneinfo/right
 
       mkdir -p "$dev/include"

pkgs/desktops/plasma-5/default.nix

···
                     # Propagate $dev so that this setup hook is propagated
                     # But only if there is a separate $dev output
                     if [ "$outputDev" != out ]; then
-                        if [ -n "$crossConfig" ]; then
-                          propagatedBuildInputs="$propagatedBuildInputs @dev@"
-                        else
-                          propagatedNativeBuildInputs="$propagatedNativeBuildInputs @dev@"
-                        fi
+                        propagatedBuildInputs="$propagatedBuildInputs @dev@"
                     fi
                 fi
               '';

pkgs/development/compilers/jsonnet/default.nix

···
 
 stdenv.mkDerivation {
   name = "jsonnet-${version}";
+  version = version;
 
   src = fetchFromGitHub {
     rev = "v${version}";

pkgs/development/compilers/openjdk-darwin/8.nix

···
       # any package that depends on the JRE has $CLASSPATH set up
       # properly.
       mkdir -p $out/nix-support
-      printWords ${setJavaClassPath} > $out/nix-support/propagated-native-build-inputs
+      printWords ${setJavaClassPath} > $out/nix-support/propagated-build-inputs
 
       install_name_tool -change /usr/X11/lib/libfreetype.6.dylib ${freetype}/lib/libfreetype.6.dylib $out/jre/lib/libfontmanager.dylib
 

pkgs/development/compilers/openjdk-darwin/default.nix

···
       # any package that depends on the JRE has $CLASSPATH set up
       # properly.
       mkdir -p $out/nix-support
-      printWords ${setJavaClassPath} > $out/nix-support/propagated-native-build-inputs
+      printWords ${setJavaClassPath} > $out/nix-support/propagated-build-inputs
 
       install_name_tool -change /usr/X11/lib/libfreetype.6.dylib ${freetype}/lib/libfreetype.6.dylib $out/jre/lib/libfontmanager.dylib
 

pkgs/development/compilers/openjdk/7.nix

···
     preFixup = ''
       prefix=$jre stripDirs "$stripDebugList" "''${stripDebugFlags:--S}"
       patchELF $jre
-      propagatedNativeBuildInputs+=" $jre"
+      propagatedBuildInputs+=" $jre"
 
       # Propagate the setJavaClassPath setup hook from the JRE so that
       # any package that depends on the JRE has $CLASSPATH set up
       # properly.
       mkdir -p $jre/nix-support
-      printWords ${setJavaClassPath} > $jre/nix-support/propagated-native-build-inputs
+      printWords ${setJavaClassPath} > $jre/nix-support/propagated-build-inputs
 
       # Set JAVA_HOME automatically.
       mkdir -p $out/nix-support

pkgs/development/compilers/openjdk/8.nix

···
     preFixup = ''
       prefix=$jre stripDirs "$stripDebugList" "''${stripDebugFlags:--S}"
       patchELF $jre
-      propagatedNativeBuildInputs+=" $jre"
+      propagatedBuildInputs+=" $jre"
 
       # Propagate the setJavaClassPath setup hook from the JRE so that
       # any package that depends on the JRE has $CLASSPATH set up
       # properly.
       mkdir -p $jre/nix-support
-      printWords ${setJavaClassPath} > $jre/nix-support/propagated-native-build-inputs
+      printWords ${setJavaClassPath} > $jre/nix-support/propagated-build-inputs
 
       # Set JAVA_HOME automatically.
       mkdir -p $out/nix-support

pkgs/development/compilers/openjdk/9.nix

···
     preFixup = ''
       prefix=$jre stripDirs "$stripDebugList" "''${stripDebugFlags:--S}"
       patchELF $jre
-      propagatedNativeBuildInputs+=" $jre"
+      propagatedBuildInputs+=" $jre"
 
       # Propagate the setJavaClassPath setup hook from the JRE so that
       # any package that depends on the JRE has $CLASSPATH set up
       # properly.
       mkdir -p $jre/nix-support
       #TODO or printWords?  cf https://github.com/NixOS/nixpkgs/pull/27427#issuecomment-317293040
-      echo -n "${setJavaClassPath}" > $jre/nix-support/propagated-native-build-inputs
+      echo -n "${setJavaClassPath}" > $jre/nix-support/propagated-build-inputs
 
       # Set JAVA_HOME automatically.
       mkdir -p $out/nix-support

pkgs/development/compilers/oraclejdk/jdk-linux-base.nix

···
     ln -s $jrePath/lib/${architecture}/libnpjp2.so $jrePath/lib/${architecture}/plugins
 
     mkdir -p $out/nix-support
-    printWords ${setJavaClassPath} > $out/nix-support/propagated-native-build-inputs
+    printWords ${setJavaClassPath} > $out/nix-support/propagated-build-inputs
 
     # Set JAVA_HOME automatically.
     cat <<EOF >> $out/nix-support/setup-hook

pkgs/development/compilers/oraclejdk/jdk9-linux.nix

···
     ln -s $out $out/jre
 
     mkdir -p $out/nix-support
-    printWords ${setJavaClassPath} > $out/nix-support/propagated-native-build-inputs
+    printWords ${setJavaClassPath} > $out/nix-support/propagated-build-inputs
 
     # Set JAVA_HOME automatically.
     cat <<EOF >> $out/nix-support/setup-hook

pkgs/development/compilers/zulu/8.nix

···
     find $out -name "*.so" -exec patchelf --set-rpath "$rpath" {} \;
 
     mkdir -p $out/nix-support
-    printWords ${setJavaClassPath} > $out/nix-support/propagated-native-build-inputs
+    printWords ${setJavaClassPath} > $out/nix-support/propagated-build-inputs
 
     # Set JAVA_HOME automatically.
     cat <<EOF >> $out/nix-support/setup-hook

pkgs/development/compilers/zulu/default.nix

···
     find $out -name "*.so" -exec patchelf --set-rpath "$rpath" {} \;
 
     mkdir -p $out/nix-support
-    printWords ${setJavaClassPath} > $out/nix-support/propagated-native-build-inputs
+    printWords ${setJavaClassPath} > $out/nix-support/propagated-build-inputs
 
     # Set JAVA_HOME automatically.
     cat <<EOF >> $out/nix-support/setup-hook

pkgs/development/interpreters/python/build-python-package.nix

···
-/* This function provides a generic Python package builder.  It is
-   intended to work with packages that use `distutils/setuptools'
-   (http://pypi.python.org/pypi/setuptools/), which represents a large
-   number of Python packages nowadays.  */
+# This function provides a generic Python package builder,
+# and can build packages that use distutils, setuptools or flit.
 
 { lib
 , python
-, mkPythonDerivation
+, wrapPython
+, setuptools
+, unzip
+, ensureNewerSourcesHook
+, pythonModule
+, namePrefix
 , bootstrapped-pip
 , flit
 }:
···
   flit-specific = import ./build-python-package-flit.nix { inherit python flit; };
   wheel-specific = import ./build-python-package-wheel.nix { };
   common = import ./build-python-package-common.nix { inherit python bootstrapped-pip; };
+  mkPythonDerivation = import ./mk-python-derivation.nix {
+    inherit lib python wrapPython setuptools unzip ensureNewerSourcesHook pythonModule namePrefix;
+  };
 in
 
 {

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

···
     in rec {
       inherit libPrefix sitePackages x11Support hasDistutilsCxxPatch;
       executable = libPrefix;
-      buildEnv = callPackage ../../wrapper.nix { python = self; };
+      buildEnv = callPackage ../../wrapper.nix { python = self; inherit (pythonPackages) requiredPythonModules; };
       withPackages = import ../../with-packages.nix { inherit buildEnv pythonPackages;};
       pkgs = pythonPackages;
       isPy2 = true;

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

···
   in rec {
     inherit libPrefix sitePackages x11Support;
     executable = "${libPrefix}m";
-    buildEnv = callPackage ../../wrapper.nix { python = self; };
+    buildEnv = callPackage ../../wrapper.nix { python = self; inherit (pythonPackages) requiredPythonModules; };
     withPackages = import ../../with-packages.nix { inherit buildEnv pythonPackages;};
     pkgs = pythonPackages;
     isPy3 = true;

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

···
   in rec {
     inherit libPrefix sitePackages x11Support;
     executable = "${libPrefix}m";
-    buildEnv = callPackage ../../wrapper.nix { python = self; };
+    buildEnv = callPackage ../../wrapper.nix { python = self; inherit (pythonPackages) requiredPythonModules; };
     withPackages = import ../../with-packages.nix { inherit buildEnv pythonPackages;};
     pkgs = pythonPackages;
     isPy3 = true;

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

···
   in rec {
     inherit libPrefix sitePackages x11Support;
     executable = "${libPrefix}m";
-    buildEnv = callPackage ../../wrapper.nix { python = self; };
+    buildEnv = callPackage ../../wrapper.nix { python = self; inherit (pythonPackages) requiredPythonModules; };
     withPackages = import ../../with-packages.nix { inherit buildEnv pythonPackages;};
     pkgs = pythonPackages;
     isPy3 = true;

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

···
-/* Generic builder for Python packages that come without a setup.py. */
+# Generic builder.
 
 { lib
 , python
···
 , setuptools
 , unzip
 , ensureNewerSourcesHook
+# Whether the derivation provides a Python module or not.
+, pythonModule
+, namePrefix
 }:
 
 { name ? "${attrs.pname}-${attrs.version}"
-
-# by default prefix `name` e.g. "python3.3-${name}"
-, namePrefix ? python.libPrefix + "-"
 
 # Dependencies for building the package
 , buildInputs ? []
···
 then throw "${name} not supported for interpreter ${python.executable}"
 else
 
-python.stdenv.mkDerivation (builtins.removeAttrs attrs ["disabled" "checkInputs"] // {
+python.stdenv.mkDerivation (builtins.removeAttrs attrs [
+    "disabled" "checkInputs" "doCheck" "doInstallCheck" "dontWrapPythonPrograms" "catchConflicts"
+  ] // {
 
   name = namePrefix + name;
 
-  inherit pythonPath;
-
-  buildInputs = [ wrapPython ] ++ buildInputs ++ pythonPath
-    ++ [ (ensureNewerSourcesHook { year = "1980"; }) ]
+  buildInputs = ([ wrapPython (ensureNewerSourcesHook { year = "1980"; }) ]
     ++ (lib.optional (lib.hasSuffix "zip" attrs.src.name or "") unzip)
-    ++ lib.optionals doCheck checkInputs;
+    ++ lib.optionals doCheck checkInputs
+    ++ lib.optional catchConflicts setuptools # If we nog longer propagate setuptools
+    ++ buildInputs
+    ++ pythonPath
+  );
 
-  # propagate python/setuptools to active setup-hook in nix-shell
+  # Propagate python and setuptools. We should stop propagating setuptools.
   propagatedBuildInputs = propagatedBuildInputs ++ [ python setuptools ];
 
   # Python packages don't have a checkPhase, only an installCheckPhase
···
 
   passthru = {
     inherit python; # The python interpreter
+    inherit pythonModule;
   } // passthru;
 
-  meta = with lib.maintainers; {
+  meta = {
     # default to python's platforms
     platforms = python.meta.platforms;
-  } // meta // {
-    # add extra maintainer(s) to every package
-    maintainers = (meta.maintainers or []) ++ [ chaoflow ];
-    # a marker for release utilities to discover python packages
     isBuildPythonPackage = python.meta.platforms;
-  };
+  } // meta;
 })

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

···
     inherit zlibSupport libPrefix sitePackages;
     executable = "pypy";
     isPypy = true;
-    buildEnv = callPackage ../../wrapper.nix { python = self; };
+    buildEnv = callPackage ../../wrapper.nix { python = self; inherit (pythonPackages) requiredPythonModules; };
     interpreter = "${self}/bin/${executable}";
     withPackages = import ../../with-packages.nix { inherit buildEnv pythonPackages;};
     pkgs = pythonPackages;

pkgs/development/interpreters/python/wrap.sh

···
 
 # Adds the lib and bin directories to the PYTHONPATH and PATH variables,
 # respectively. Recurses on any paths declared in
-# `propagated-native-build-inputs`, while avoiding duplicating paths by
+# `propagated-build-inputs`, while avoiding duplicating paths by
 # flagging the directories it has visited in `pythonPathsSeen`.
 _addToPythonPath() {
     local dir="$1"
···
     addToSearchPath program_PATH $dir/bin
 
     # Inspect the propagated inputs (if they exist) and recur on them.
-    local prop="$dir/nix-support/propagated-native-build-inputs"
+    local prop="$dir/nix-support/propagated-build-inputs"
     if [ -e $prop ]; then
         local new_path
         for new_path in $(cat $prop); do

pkgs/development/interpreters/python/wrapper.nix

···
 , extraLibs ? []
 , extraOutputsToInstall ? []
 , postBuild ? ""
-, ignoreCollisions ? false }:
+, ignoreCollisions ? false
+, requiredPythonModules
+, }:
 
 # Create a python executable that knows about additional packages.
 let
-  recursivePthLoader = import ../../python-modules/recursive-pth-loader/default.nix { stdenv = stdenv; python = python; };
   env = let
-    paths = stdenv.lib.closePropagation (extraLibs ++ [ python recursivePthLoader ] ) ;
+    paths = requiredPythonModules (extraLibs ++ [ python ] ) ;
   in buildEnv {
     name = "${python.name}-env";
 

pkgs/development/libraries/boost/generic.nix

···
 stdenv.mkDerivation {
   name = "boost-${version}";
 
-  inherit src patches;
+  inherit src patches version;
 
   meta = {
     homepage = http://boost.org/;

pkgs/development/libraries/grantlee/5/setup-hook.sh

···
     [ -d "$1/$grantleePluginPrefix" ]
 }
 
-_grantleeCrossEnvHook() {
-    if providesQtRuntime "$1"; then
-        propagatedBuildInputs+=" $1"
-        propagatedUserEnvPkgs+=" $1"
-    fi
-}
-crossEnvHooks+=(_grantleeCrossEnvHook)
-
 _grantleeEnvHook() {
     if providesGrantleeRuntime "$1"; then
-        propagatedNativeBuildInputs+=" $1"
-        if [ -z "$crossConfig" ]; then
+        propagatedBuildInputs+=" $1"
         propagatedUserEnvPkgs+=" $1"
-        fi
     fi
 }
-envHooks+=(_grantleeEnvHook)
+if [ "$crossEnv" ]; then
+    crossEnvHooks+=(_grantleeEnvHook)
+else
+    envHooks+=(_grantleeEnvHook)
+fi

pkgs/development/libraries/kde-frameworks/default.nix

···
                     # Propagate $dev so that this setup hook is propagated
                     # But only if there is a separate $dev output
                     if [ "$outputDev" != out ]; then
-                        if [ -n "$crossConfig" ]; then
-                          propagatedBuildInputs="$propagatedBuildInputs @dev@"
-                        else
-                          propagatedNativeBuildInputs="$propagatedNativeBuildInputs @dev@"
-                        fi
+                        propagatedBuildInputs="$propagatedBuildInputs @dev@"
                     fi
                 fi
               '';

pkgs/development/libraries/kmsxx/default.nix

···
 { stdenv, fetchFromGitHub, cmake, pkgconfig, libdrm, python }:
 
 stdenv.mkDerivation rec {
-  name = "kmsxx-2017-10-10";
+  pname = "kmsxx";
+  version = "2017-10-10";
+  name = pname + "-" + version;
 
   src = fetchFromGitHub {
     owner = "tomba";

pkgs/development/libraries/libinput/default.nix

···
 with stdenv.lib;
 stdenv.mkDerivation rec {
   name = "libinput-${version}";
-  version = "1.9.1";
+  version = "1.9.2";
 
   src = fetchurl {
     url = "http://www.freedesktop.org/software/libinput/${name}.tar.xz";
-    sha256 = "1y3559146zlfizncky1jlly226i66vwikxhpdkw0jg8v47j0sy7h";
+    sha256 = "0fyy050hzk47g7305lx5pgyh2abvq7qs4xd3nn1is7zy3wj56s6x";
   };
 
   outputs = [ "out" "dev" ];

pkgs/development/libraries/libxml2/default.nix

···
 
 in stdenv.mkDerivation rec {
   name = "libxml2-${version}";
-  version = "2.9.5";
+  version = "2.9.7";
 
   src = fetchurl {
     url = "http://xmlsoft.org/sources/${name}.tar.gz";
-    sha256 = "0f6d5nkvcfx8yqis2dwrnv6qaj0nhiifz49y657vmrwwxvnc2ca0";
+    sha256 = "034hylzspvkm0p4bczqbf8q05a7r2disr8dz725x4bin61ymwg7n";
   };
 
   outputs = [ "bin" "dev" "out" "man" "doc" ]

pkgs/development/libraries/libxslt/default.nix

···
 with stdenv.lib;
 
 stdenv.mkDerivation rec {
-  name = "libxslt-1.1.29";
+  pname = "libxslt";
+  version = "1.1.29";
+  name = pname + "-" + version;
 
   src = fetchurl {
     url = "http://xmlsoft.org/sources/${name}.tar.gz";
···
     moveToOutput share/man/man1 "$bin"
   '' + optionalString pythonSupport ''
     mkdir -p $py/nix-support
-    echo ${libxml2.py} >> $py/nix-support/propagated-native-build-inputs
+    echo ${libxml2.py} >> $py/nix-support/propagated-build-inputs
     moveToOutput lib/python2.7 "$py"
   '';
 

pkgs/development/libraries/physics/rivet/default.nix

···
 
   postPatch = "patchShebangs ./src/Analyses/cat_with_lines";
 
-  pythonPath = []; # python wrapper support
-
   patches = [
     ./darwin.patch # configure relies on impure sw_vers to -Dunix
   ];

pkgs/development/libraries/qt-5/hooks/qtbase-setup-hook.sh

···
 # package depending on the building package. (This is necessary in case
 # the building package does not provide runtime dependencies itself and so
 # would not be propagated to the user environment.)
-qtCrossEnvHook() {
+qtEnvHook() {
     addToQMAKEPATH "$1"
     if providesQtRuntime "$1"; then
         if [ "z${!outputBin}" != "z${!outputDev}" ]; then
···
         propagatedUserEnvPkgs+=" $1"
     fi
 }
-crossEnvHooks+=(qtCrossEnvHook)
-
-qtEnvHook() {
-    addToQMAKEPATH "$1"
-    if providesQtRuntime "$1"; then
-        if [ "z${!outputBin}" != "z${!outputDev}" ]; then
-            propagatedNativeBuildInputs+=" $1"
-        fi
-        if [ -z "$crossConfig" ]; then
-        propagatedUserEnvPkgs+=" $1"
-        fi
-    fi
-}
-envHooks+=(qtEnvHook)
+if [ "$crossConfig" ]; then
+   crossEnvHooks+=(qtEnvHook)
+else
+   envHooks+=(qtEnvHook)
+fi
 
 postPatchMkspecs() {
     local bin="${!outputBin}"

pkgs/development/perl-modules/generic/builder.sh

···
     # dependencies in the user environment (since Perl modules don't
     # have something like an RPATH, so the only way to find the
     # dependencies is to have them in the PERL5LIB variable).
-    if test -e $out/nix-support/propagated-native-build-inputs; then
-        ln -s $out/nix-support/propagated-native-build-inputs $out/nix-support/propagated-user-env-packages
+    if test -e $out/nix-support/propagated-build-inputs; then
+        ln -s $out/nix-support/propagated-build-inputs $out/nix-support/propagated-user-env-packages
     fi
 }
 

pkgs/development/python-modules/absl-py/default.nix

···
 
 buildPythonPackage rec {
   pname = "absl-py";
-  version = "0.1.3";
+  version = "0.1.5";
   name = "${pname}-${version}";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "017wc85i7l3vpjzw3shgb7k7n0jfid88g09dlf1kgdy4ll0sjfax";
+    sha256 = "94943ed0cd77077fe2d18e79b2f28d3e92f585f7d1c6edc75e640121f3c5d580";
   };
 
   propagatedBuildInputs = [ six ];

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

···
 
 buildPythonPackage rec {
   pname = "aiohttp";
-  version = "2.3.2";
+  version = "2.3.3";
   name = "${pname}-${version}";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "42373fbdbe8f09233c17e74f53cee877bc7d5b495b4fc14c32a119255e85e736";
+    sha256 = "0a2e33e90560dacb819b095b9d9611597925d75d1b93dd9490055d3826d98a82";
   };
 
   disabled = pythonOlder "3.4";

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

···
   ... }:
 
 buildPythonPackage rec {
-  name = "arelle-${version}${lib.optionalString (!gui) "-headless"}";
+  pname = "arelle-${version}${lib.optionalString (!gui) "-headless"}";
   version = "2017-08-24";
+  name = pname + "-" + version;
 
   disabled = !isPy3k;
 

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

···
 buildPythonPackage rec {
   name = "${pname}-${version}";
   pname = "argcomplete";
-  version = "1.9.2";
+  version = "1.9.3";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "d6ea272a93bb0387f758def836e73c36fff0c54170258c212de3e84f7db8d5ed";
+    sha256 = "d97b7f3cfaa4e494ad59ed6d04c938fc5ed69b590bd8f53274e258fb1119bd1b";
   };
 
   doCheck = false; # bash-completion test fails with "compgen: command not found".

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

···
 buildPythonPackage rec {
   pname = "asn1ate";
   date = "20160810";
-  name = "${pname}-unstable-${date}";
+  version = "unstable-${date}";
+  name = "${pname}-${version}";
 
   src = fetchFromGitHub {
     sha256 = "04pddr1mh2v9qq8fg60czwvjny5qwh4nyxszr3qc4bipiiv2xk9w";

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

···
 { stdenv, lib, buildPythonPackage, fetchFromGitHub, augeas, cffi }:
 buildPythonPackage rec {
-    name = "augeas-${version}";
+    pname = "augeas";
     version = "1.0.2";
+    name = pname + "-" + version;
 
     src = fetchFromGitHub {
       owner = "hercules-team";

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

···
 }:
 
 buildPythonPackage rec {
-  name = "blockdiag-${version}";
+  pname = "blockdiag";
   version = "1.5.3";
+  name = pname + "-" + version;
 
   src = fetchurl {
     url = "https://bitbucket.org/blockdiag/blockdiag/get/${version}.tar.bz2";

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

···
   };
   setuptools_source = fetchPypi {
     pname = "setuptools";
-    version = "36.4.0";
+    version = "36.7.1";
     format = "wheel";
-    sha256 = "4d54c0bfee283e78609169213f9c075827d5837086f58b588b417b093c23464b";
+    sha256 = "eaacfa35eb11199d0b017df416421781a75209817bff3f94820556e36c49bd77";
   };
 
   # TODO: Shouldn't be necessary anymore for pip > 9.0.1!

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

···
 
 buildPythonPackage rec {
   pname = "Bottleneck";
-  name = "Bottleneck-${version}";
   version = "1.2.1";
+  name = pname + "-" + version;
+
   src = fetchPypi {
     inherit pname version;
     sha256 = "6efcde5f830aed64feafca0359b51db0e184c72af8ba6675b4a99f263922eb36";
···
   postPatch = ''
     substituteInPlace setup.py --replace "__builtins__.__NUMPY_SETUP__ = False" ""
   '';
-}
+}

pkgs/development/python-modules/cgroup-utils/default.nix

···
 
 buildPythonPackage rec {
   version = "0.6";
-  name = "cgroup-utils-${version}";
+  pname = "cgroup-utils";
+  name = pname + "-" + version;
 
   buildInputs = [ pep8 nose ];
   # Pep8 tests fail...

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

···
 { stdenv, buildPythonPackage, fetchFromGitHub, six, pythonOlder }:
 
 buildPythonPackage rec {
-  name = "construct-${version}";
+  pname = "construct";
   version = "2.8.16";
+  name = pname + "-" + version;
 
   src = fetchFromGitHub {
     owner = "construct";

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

···
 
 buildPythonPackage rec {
   pname = "coverage";
-  version = "4.4.1";
+  version = "4.4.2";
   name = "${pname}-${version}";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "7a9c44400ee0f3b4546066e0710e1250fd75831adc02ab99dda176ad8726f424";
+    sha256 = "309d91bd7a35063ec7a0e4d75645488bfab3f0b66373e7722f23da7f5b0f34cc";
   };
 
   # No tests in archive

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

···
 
 buildPythonPackage rec {
   pname = "cufflinks";
-  version = "0.12.0";
+  version = "0.12.1";
   name = "${pname}-${version}";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "04ninvwm6277n3hqc17ririss90cd832wza3q3vf115rrrds3xyy";
+    sha256 = "8f11e4b6326cc5b2a18011c09fb64f178ba21002f337fd305f64818012a6c679";
   };
 
   propagatedBuildInputs = [ pandas plotly colorlover ];

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

···
 , python
 }:
 buildPythonPackage rec {
-  name = "cymem-${version}";
+  pname = "cymem";
   version = "1.31.2";
+  name = pname + "-" + version;
 
   src = fetchFromGitHub {
     owner = "explosion";
···
   };
 
   propagatedBuildInputs = [
-   cython   
+   cython
   ];
-    
+
   checkPhase = ''
     cd cymem/tests
     ${python.interpreter} -m unittest discover -p "*test*"
   '';
-  
+
   meta = with stdenv.lib; {
     description = "Cython memory pool for RAII-style memory management";
     homepage = https://github.com/explosion/cymem;

pkgs/development/python-modules/django-hijack/default.nix

···
   django, django_compat, django_nose
 }:
 buildPythonPackage rec {
-  name = "django-hijack-${version}";
+  pname = "django-hijack";
   version = "2.1.4";
+  name = pname + "-" + version;
 
   # the pypi packages don't include everything required for the tests
   src = fetchFromGitHub {
···
     license = licenses.mit;
     maintainers = with maintainers; [ ris ];
   };
-}
+}

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

···
 { stdenv, buildPythonPackage, fetchurl, django }:
 buildPythonPackage rec {
-  version = "3.7.1";
+  version = "3.7.3";
   pname = "djangorestframework";
   name = "${pname}-${version}";
 
   src = fetchurl {
     url = "mirror://pypi/d/djangorestframework/${name}.tar.gz";
-    sha256 = "305b2c6564ca46d3b558ba21110ed717135c467adf1a6dfd192bd85f4bb04d50";
+    sha256 = "067960e5e9e5586d3b2d53a1d626c4800dc33cd8309487d404fc63355674556f";
   };
 
   # Test settings are missing

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

···
 , pytest, dns }:
 
 buildPythonApplication rec {
-  name = "${pname}-${majorversion}.${minorversion}";
+  name = "${pname}-${version}";
   pname = "dkimpy";
   majorversion = "0.6";
   minorversion = "2";
+  version = "${majorversion}.${minorversion}";
 
   src = fetchurl {
     url = "https://launchpad.net/${pname}/${majorversion}/${majorversion}.${minorversion}/+download/${name}.tar.gz";

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

···
 , git, glibcLocales }:
 
 buildPythonPackage rec {
-  version = "0.18.5";
+  version = "0.18.6";
   pname = "dulwich";
   name = "${pname}-${version}";
 
   src = fetchurl {
     url = "mirror://pypi/d/dulwich/${name}.tar.gz";
-    sha256 = "838bac318fd0ed79e0eedb6cfd53b6424dc618fec6b99dc959881b12da7bd6e0";
+    sha256 = "38a04406bc68315794c3bab37c7d4ed137fb8a839482d8894e72b0d9b3eb41a9";
   };
 
   LC_ALL = "en_US.UTF-8";

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

···
 buildPythonPackage rec {
   name = "${pname}-${version}";
   pname = "ECPy";
-  version = "0.8.1";
+  version = "0.8.2";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "0ab60sx4bbsmccwmdvz1023r0cbzi4phar4ipzn5npdj5gw1ny4l";
+    sha256 = "0509a90714448ef47ef727cb7aee3415995c883c945e972521b5838fa4c50e24";
   };
 
   buildInputs = [ hidapi pycrypto pillow protobuf future ];

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

···
 
 buildPythonPackage rec {
   pname = "Faker";
-  version = "0.8.6";
+  version = "0.8.7";
   name = "${pname}-${version}";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "3c98dd04bba667ecfddb77fcd0dfd19b376b258d21beeaf5b95578826e275a83";
+    sha256 = "bf7dabcd6807c8829da28a4de491adf7998af506b8571db6a6eb58161157248a";
   };
 
   checkInputs = [

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

···
 { stdenv, buildPythonPackage, fetchPypi }:
-let
+
+buildPythonPackage rec {
   pname = "first";
   version = "2.0.1";
-in
-buildPythonPackage {
-  name = "${pname}-${version}";
+  name = pname + "-" + version;
 
   src = fetchPypi {
     inherit pname version;

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

···
 , pytest }:
 
 buildPythonPackage rec {
-  name = "geopandas-${version}";
+  pname = "geopandas";
   version = "0.3.0";
+  name = pname + "-" + version;
 
   src = fetchFromGitHub {
     owner = "geopandas";

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

···
 { stdenv, fetchurl, buildPythonPackage, isPyPy, python, libev, greenlet }:
 
 buildPythonPackage rec {
-  name = "gevent-1.1.2";
+  pname = "gevent";
+  version = "1.2.2";
+  name = pname + "-" + version;
 
   src = fetchurl {
     url = "mirror://pypi/g/gevent/${name}.tar.gz";
-    sha256 = "cb15cf73d69a2eeefed330858f09634e2c50bf46da9f9e7635730fcfb872c02c";
+    sha256 = "0bbbjvi423y9k9xagrcsimnayaqymg6f2dj76m9z3mjpkjpci4a7";
   };
-
-  # Why do we have this patch?
-  postPatch = ''
-    substituteInPlace libev/ev.c --replace \
-      "ecb_inline void ecb_unreachable (void) ecb_noreturn" \
-      "ecb_inline ecb_noreturn void ecb_unreachable (void)"
-  '';
 
   buildInputs = [ libev ];
   propagatedBuildInputs = stdenv.lib.optionals (!isPyPy) [ greenlet ];

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

···
 
 buildPythonPackage rec {
   version = "3.1.2";
-  name = "gflags-${version}";
+  pname = "gflags";
+  name = pname + "-" + version;
 
   src = fetchPypi {
     inherit version;

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

···
 { lib, fetchurl, buildPythonPackage, numpy }:
 
 buildPythonPackage rec {
-  name = "hmmlearn-${version}";
+  pname = "hmmlearn";
   version = "0.2.0";
+  name = pname + "-" + version;
 
   src = fetchurl {
     url = "mirror://pypi/h/hmmlearn/${name}.tar.gz";

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

···
 { stdenv, buildPythonPackage, fetchurl, pytest }:
+
 buildPythonPackage rec {
-  name = "hyperlink-${version}";
-  version = "17.3.0";
+  pname = "hyperlink";
+  version = "17.3.1";
+  name = pname + "-" + version;
 
   src = fetchurl {
     url = "mirror://pypi/h/hyperlink/${name}.tar.gz";
-    sha256 = "06mgnxwjzx8hv34bifc7jvgxz21ixhk5s6xy2kd84hdrlbfvpbfx";
+    sha256 = "bc4ffdbde9bdad204d507bd8f554f16bba82dd356f6130cb16f41422909c33bc";
   };
 
   checkInputs = [ pytest ];

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

···
 
 buildPythonPackage rec {
   pname = "ipywidgets";
-  version = "7.0.3";
+  version = "7.0.5";
   name = "${pname}-${version}";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "f98b4c3719097c9d2e6489f303db520b20bd4de3e0b1d6d4f92f81bfe3c2a0c8";
+    sha256 = "321be3dc48193130ba16e8080172bb5cd052eb65e3ad0ea7b5f80ff73e24bc54";
   };
 
   # Tests are not distributed

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

···
     sha256 = "f6d5973573e76b1fd2ea75f6dcd6445d02d41ff3af5fc61b275b4e323d1dd396";
   };
 
+  postPatch = ''
+    substituteInPlace requirements.txt --replace "parso==0.1.0" "parso"
+  '';
+
   checkInputs = [ pytest glibcLocales tox pytestcov ];
 
   propagatedBuildInputs = [ parso ];

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

···
 
 buildPythonPackage rec {
   pname = "Keras";
-  version = "2.0.9";
+  version = "2.1.1";
   name = "${pname}-${version}";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "6b8572cf1b4a22fd0120b7c23382ba4fa04a6f0397e02af1249be9a7309d1767";
+    sha256 = "f0ca2458c60d9711edf4291230b31795307ad3781cb6232ff4792b53c8f55123";
   };
 
   checkInputs = [

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

···
 }:
 
 buildPythonPackage rec {
-  name = "keystoneclient-${version}";
+  pname = "keystoneclient";
   version = "1.8.1";
+  name = pname + "-" + version;
 
   src = fetchFromGitHub {
     owner = "openstack";

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

···
 { lib, buildPythonPackage, fetchurl, pkgs, pytestrunner }:
 
-let
+buildPythonPackage rec {
   pname = "keyutils";
   version = "0.5";
-in buildPythonPackage rec {
   name = "${pname}-${version}";
 
   src = fetchurl {

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

···
-{ stdenv 
+{ stdenv
 , lib
 , buildPythonPackage
 , fetchFromGitHub
···
 , python
 , cudaSupport ? false, cudatoolkit
 , openclSupport ? true, ocl-icd, clblas
-}: 
+}:
 
 buildPythonPackage rec {
-  name = "libgpuarray-${version}";
+  pname = "libgpuarray";
   version = "0.6.9";
+  name = pname + "-" + version;
 
   src = fetchFromGitHub {
-    owner = "Theano"; 
+    owner = "Theano";
     repo = "libgpuarray";
     rev = "v${version}";
     sha256 = "06z47ls42a37gbv0x7f3l1qvils7q0hvy02s95l530klgibp19s0";
-  }; 
+  };
 
   # requires a GPU
   doCheck = false;
···
     export NIX_CFLAGS_COMPILE="-L $out/lib -I $out/include $NIX_CFLAGS_COMPILE"
 
     cd ..
-  ''; 
+  '';
 
   postFixup = ''
     rm $out/lib/libgpuarray-static.a
···
 
   enableParallelBuilding = true;
 
-  buildInputs = [ 
-    cmake 
-    cython 
+  buildInputs = [
+    cmake
+    cython
     nose
-  ]; 
+  ];
 
   meta = with stdenv.lib; {
     homepage = "https://github.com/Theano/libgpuarray";

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

···
 buildPythonPackage rec {
   name = "${pname}-${version}";
   pname = "libtmux";
-  version = "0.7.5";
+  version = "0.7.7";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "12e5006e59b7d98af5d1a9294f9c8ff2829ac2c1c6ae23dc73c280100b15f485";
+    sha256 = "5670c8da8d0192d932ac1e34f010e0eeb098cdb2af6daad0307b5418e7a37733";
   };
 
   buildInputs = [ pytest_29 ];

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

···
 }:
 
 buildPythonPackage rec {
-  name = "llfuse-1.0";
+  pname = "llfuse";
+  version = "1.0";
+  name = pname + "-" + version;
 
   src = fetchurl {
     url = "mirror://pypi/l/llfuse/${name}.tar.bz2";

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

···
+{ buildPythonPackage
+, fetchPypi
+, mock
+, unittest2
+, msgpack
+, requests
+, flask
+, gevent
+, pyzmq
+}:
+
+buildPythonPackage rec {
+  pname = "locustio";
+  version = "0.8.1";
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "64583987ba1c330bb071aee3e29d2eedbfb7c8b342fa064bfb74fafcff660d61";
+  };
+
+  patchPhase = ''
+    sed -i s/"pyzmq=="/"pyzmq>="/ setup.py
+  '';
+
+  propagatedBuildInputs = [ msgpack requests flask gevent pyzmq ];
+  buildInputs = [ mock unittest2 ];
+
+  meta = {
+    homepage = http://locust.io/;
+    description = "A load testing tool";
+  };
+}

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

···
 
 buildPythonPackage rec {
   pname = "markdown2";
-  version = "2.3.4";
+  version = "2.3.5";
   name = "${pname}-${version}";
 
   src = fetchurl {
     url = "mirror://pypi/m/markdown2/${name}.zip";
-    sha256 = "264731e7625402227ff6fb01f2d814882da7705432659a18a419c508e8bfccb1";
+    sha256 = "8bb9a24eb2aa02f1427aabe46483f0f0215ab18c8a345315ae8e2ee3c3a09c03";
   };
 
   meta = with stdenv.lib; {

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

···
 }:
 
 buildPythonPackage rec {
-  name = "murmurhash-${version}";
+  pname = "murmurhash";
   version = "0.26.4";
-  
+  name = pname + "-" + version;
+
   src = fetchFromGitHub {
     owner = "explosion";
     repo = "murmurhash";
     rev = "0.26.4";
-    sha256 = "0n2j0glhlv2yh3fjgbg4d79j1c1fpchgjd4vnpw908l9mzchhmdv";    
+    sha256 = "0n2j0glhlv2yh3fjgbg4d79j1c1fpchgjd4vnpw908l9mzchhmdv";
   };
 
   buildInputs = [
    cython
   ];
-  
+
   checkPhase = ''
     cd murmurhash/tests
     ${python.interpreter} -m unittest discover -p "*test*"
   '';
-  
+
   meta = with stdenv.lib; {
     description = "Cython bindings for MurmurHash2";
     homepage = https://github.com/explosion/murmurhash;

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

···
 buildPythonPackage rec {
   name = "${pname}-${version}";
   pname = "natsort";
-  version = "5.1.0";
+  version = "5.1.1";
 
   buildInputs = [
     hypothesis
···
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "5db0fd17c9f8ef3d54962a6e46159ce4807c630f0931169cd15ce54f2ac395b9";
+    sha256 = "9ffbfb74bf3fc3905be1b9b052ed865675651e38fcd972ed1ed5c64a02f93cbd";
   };
 
   # do not run checks on nix_run_setup.py

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

···
 buildPythonPackage rec {
   pname = "nilearn";
   version = "0.3.1";
-  name = "nilearn-${version}";
+  name = pname + "-" + version;
 
   src = fetchPypi {
     inherit pname version;

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

···
 }:
 
 buildPythonPackage rec {
-  name = "nwdiag-1.0.3";
+  pname = "nwdiag";
+  version = "1.0.4";
+  name = pname + "-" + version;
 
   src = fetchurl {
     url = "mirror://pypi/n/nwdiag/${name}.tar.gz";
-    sha256 = "0n7ary1fngxk8bk15vabc8fhnmxlh098piciwaviwn7l4a5q1zys";
+    sha256 = "002565875559789a2dfc5f578c07abdf44269c3f7cdf78d4809bdc4bdc2213fa";
   };
 
   buildInputs = [ pep8 nose unittest2 docutils ];

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

···
 
 buildPythonPackage rec {
   pname = "parso";
-  version = "0.1.0";
+  version = "0.1.1";
   name = "${pname}-${version}";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "c5279916bb417aa2bf634648ff895cf35dce371d7319744884827bfad06f8d7b";
+    sha256 = "5815f3fe254e5665f3c5d6f54f086c2502035cb631a91341591b5a564203cffb";
   };
 
   checkInputs = [ pytest ];

pkgs/development/python-modules/path.py/default.nix

···
 buildPythonPackage rec {
   pname = "path.py";
   version = "10.4";
-  name = "path.py-${version}";
+  name = pname + "-" + version;
 
   src = fetchPypi {
     inherit pname version;
···
   checkPhase = ''
     py.test test_path.py
   '';
-}
+}

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

···
 
 buildPythonPackage rec {
   pname = "phonenumbers";
-  version = "8.8.5";
+  version = "8.8.6";
   name = "${pname}-${version}";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "adb2dd985f875ac035bbdc6a1cc57e30834e106e2ff7899e09a1690b474c1774";
+    sha256 = "ab1fa853350dde91be672192b427169b29e3348c236e46ad7a757e4ac8163c8c";
   };
 
   meta = {

pkgs/development/python-modules/pip-tools/default.nix

···
 
 buildPythonPackage rec {
   pname = "pip-tools";
-  version = "1.10.1";
-  name = "pip-tools-${version}";
+  version = "1.10.2";
+  name = pname + "-" + version;
 
   src = fetchurl {
     url = "mirror://pypi/p/pip-tools/${name}.tar.gz";
-    sha256 = "37b85d69ceed97337aeefb3e52e41fe0884a505c874757a5bbaa58d92b533ce0";
+    sha256 = "d381c7249eb48350cc49447cc106df3d90e9e806b13caaede602c1cd38f61b37";
   };
 
   LC_ALL = "en_US.UTF-8";

pkgs/development/python-modules/plaster-pastedeploy/default.nix

···
 
 buildPythonPackage rec {
   pname = "plaster_pastedeploy";
-  version = "0.4.1";
+  version = "0.4.2";
   name = "${pname}-${version}";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "1lrbkya5birfmg9gnfcnsa9id28klmjcqbm33rcg69pv9sfld4jv";
+    sha256 = "2a401228c7cfbe38f728249e75af7a666f91c61d642cbb8fcb78a71df69d2754";
   };
 
   checkPhase = ''

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

···
 # the executables of git, mercurial and bazaar.
 
 buildPythonPackage rec {
-  rev  = "2.6";
-  name = "powerline-${rev}";
+  version  = "2.6";
+  pname = "powerline";
+  name = pname + "-" + version;
+
   src = fetchurl {
-    url    = "https://github.com/powerline/powerline/archive/${rev}.tar.gz";
+    url    = "https://github.com/powerline/powerline/archive/${version}.tar.gz";
     name   = "${name}.tar.gz";
     sha256 = "c108f11fe10dc910febb94b87d3abded85d4363fb950366a9e30282b9ba7c272";
   };

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

···
 with stdenv.lib;
 
 buildPythonPackage rec {
-  inherit (protobuf) name src;
+  inherit (protobuf) name src version;
   inherit disabled doCheck;
 
   NIX_CFLAGS_COMPILE =

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

···
+{ stdenv
+, buildPythonPackage
+, fetchPypi
+, darwin
+, mock
+}:
+
+buildPythonPackage rec {
+  pname = "psutil";
+  version = "5.4.1";
+  name = "${pname}-${version}";
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "42e2de159e3c987435cb3b47d6f37035db190a1499f3af714ba7af5c379b6ba2";
+  };
+
+  # No tests in archive
+  doCheck = false;
+
+  buildInputs = [] ++ stdenv.lib.optionals stdenv.isDarwin [ darwin.IOKit ];
+
+  meta = {
+    description = "Process and system utilization information interface for python";
+    homepage = https://github.com/giampaolo/psutil;
+    license = stdenv.lib.licenses.bsd3;
+  };
+}

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

···
 buildPythonPackage rec {
   version = "3.10.0";
   pname = "pwntools";
-  name = "pwntools-${version}";
+  name = pname + "-" + version;
 
   src = fetchPypi {
     inherit pname version;

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

···
 , buildPythonPackage, python-jose }:
 
 buildPythonPackage rec {
-  name = "PyGithub-${version}";
+  pname = "PyGithub";
   version = "1.32";
+  name = pname + "-" + version;
 
   src = fetchFromGitHub {
     owner = "PyGithub";

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

···
 { lib, fetchurl, buildPythonPackage, requests, six, zeroconf, protobuf }:
 
 buildPythonPackage rec {
-  name    = "PyChromecast-${version}";
+  pname = "PyChromecast";
   version = "0.8.1";
+  name = pname + "-" + version;
 
   src = fetchurl {
     url    = "mirror://pypi/p/pychromecast/${name}.tar.gz";

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

···
 # This is a dummy package providing the drop-in replacement pycryptodome.
 # https://github.com/NixOS/nixpkgs/issues/21671
 
-let
+buildPythonPackage rec {
   version = pycryptodome.version;
   pname = "pycrypto";
-in buildPythonPackage rec {
   name = "${pname}-${version}";
 
   # Cannot build wheel otherwise (zip 1980 issue)

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

···
-{ mkDerivation 
+{ mkDerivation
 , fetchFromGitHub
 }:
 
 mkDerivation rec {
-  name = "compyte-${version}";
-  version = "git-20150817"; 
+  pname = "compyte";
+  version = "git-20150817";
+  name = pname + "-" + version;
 
   src = fetchFromGitHub {
     owner = "inducer";
···
     sha256 = "1980h017qi52b7fqwm75m481xs2napgdd3fbrzkfc29k085cbign";
   };
 
-  installPhase = '' 
+  installPhase = ''
     mkdir -p $out
     cp -r * $out
   '';

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

···
 { stdenv, fetchurl, buildPythonPackage, libev }:
 
 buildPythonPackage rec {
-  name = "pyev-0.9.0";
+  pname = "pyev";
+  version = "0.9.0";
+  name = pname + "-" + version;
 
   src = fetchurl {
     url = "mirror://pypi/p/pyev/${name}.tar.gz";

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

···
 , boost, freetype, ftgl, mesa }:
 
 buildPythonPackage rec {
-  name = "pyftgl-0.4b";
+  pname = "pyftgl";
+  version = "0.4b";
+  name = pname + "-" + version;
 
   src = fetchFromGitHub {
     owner = "umlaeute";
-    repo = "pyftgl";
-    rev = "0.4b";
+    repo = name;
+    rev = version;
     sha256 = "12zcjv4cwwjihiaf74kslrdmmk4bs47h7006gyqfwdfchfjdgg4r";
   };
 

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

···
 }:
 
 buildPythonPackage rec {
-  name = "pygame-${version}";
+  pname = "pygame";
   version = "2016-05-17";
+  name = pname + "-" + version;
 
   src = fetchFromBitbucket {
     owner = "pygame";

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

···
 buildPythonPackage rec {
   major = "3.24";
   minor = "1";
-  name = "pygobject-${major}.${minor}";
+  version = "${major}.${minor}";
   format = "other";
+  pname = "pygobject";
+  name = pname + "-" + version;
 
   src = fetchurl {
     url = "mirror://gnome/sources/pygobject/${major}/${name}.tar.xz";

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

···
 { stdenv, fetchurl, python, buildPythonPackage, pkgconfig, glib }:
 
 buildPythonPackage rec {
-  name = "pygobject-${version}";
+  pname = "pygobject";
   version = "2.28.6";
   format = "other";
+  name = pname + "-" + version;
 
   src = fetchurl {
     url = "mirror://gnome/sources/pygobject/2.28/${name}.tar.xz";

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

···
 , buildPythonPackage, libglade ? null, isPy3k }:
 
 buildPythonPackage rec {
-  name = "pygtk-2.24.0";
+  pname = "pygtk";
+  version = "2.24.0";
+  name = pname + "-" + version;
 
   disabled = isPy3k;
 

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

···
 { lib, fetchurl, python, buildPythonPackage, pkgconfig, pygobject2, glib, pygtk, gnome2 }:
 
-let version = "2.10.1"; in
-
-buildPythonPackage {
-  name = "pygtksourceview-${version}";
+buildPythonPackage rec {
+  pname = "pygtksourceview";
   format = "other";
+  version = "2.10.1";
+  name = pname + "-" + version;
 
   src = fetchurl {
     url = "http://ftp.gnome.org/pub/gnome/sources/pygtksourceview/2.10/pygtksourceview-${version}.tar.bz2";

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

···
 }:
 
 buildPythonPackage rec {
-  name = "pyocr-${version}";
+  pname = "pyocr";
   version = "0.4.7";
+  name = pname + "-" + version;
 
   # Don't fetch from PYPI because it doesn't contain tests.
   src = fetchFromGitHub {

pkgs/development/python-modules/pyqt/4.x.nix

···
 { stdenv, fetchurl, pythonPackages, qt4, pkgconfig, lndir, dbus_libs, makeWrapper }:
 
 let
+  pname = "PyQt-x11-gpl";
   version = "4.12";
+
   inherit (pythonPackages) buildPythonPackage python dbus-python sip;
 in buildPythonPackage {
-  name = "PyQt-x11-gpl-${version}";
+  pname = pname;
+  name = pname + "-" + version;
+  version = version;
   format = "other";
 
   src = fetchurl {

pkgs/development/python-modules/pyqt/5.x.nix

···
 }:
 
 let
+  pname = "PyQt";
   version = "5.9";
+
   inherit (pythonPackages) buildPythonPackage python dbus-python sip;
 in buildPythonPackage {
-  name = "PyQt-${version}";
+  pname = pname;
+  version = version;
   format = "other";
+  name = pname + "-" + version;
 
   meta = with lib; {
     description = "Python bindings for Qt5";

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

···
 { stdenv, fetchurl, buildPythonPackage, isPy3k }:
 
 buildPythonPackage rec {
-  name = "Pyro-3.16";
+  pname = "Pyro";
+  version = "3.16";
+  name = pname + "-" + version;
+
   disabled = isPy3k;
 
   src = fetchurl {

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

···
 { lib, fetchFromGitHub, buildPythonPackage, cython, slurm }:
 
 buildPythonPackage rec {
-  name = "pyslurm";
+  pname = "pyslurm";
+  version = "unstable-69e4f4f";
+  name = pname + "-" + version;
 
   src = fetchFromGitHub {
     repo = "pyslurm";

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

···
 
 buildPythonPackage rec {
   pname = "PySoundFile";
-  name = "PySoundFile-${version}";
   version = "0.8.1";
+  name = pname + "-" + version;
 
   src = fetchPypi {
     inherit pname version;
···
 
     # https://github.com/bastibe/PySoundFile/issues/157
     disabled = isPyPy ||  stdenv.isi686;
-}
+}

pkgs/development/python-modules/pytest-expect/default.nix

···
 , six
 }:
 
-let
+buildPythonPackage rec {
   pname = "pytest-expect";
   version = "1.1.0";
-in buildPythonPackage rec {
   name = "${pname}-${version}";
 
   src = fetchurl {
···
     homepage = https://github.com/gsnedders/pytest-expect;
     license = lib.licenses.mit;
   };
-}
+}

pkgs/development/python-modules/pytest/2_7.nix

···
 { stdenv, pkgs, buildPythonPackage, fetchurl, isPy26, argparse, py, selenium }:
 buildPythonPackage rec {
-  name = "pytest-2.7.3";
+  pname = "pytest";
+  version = "2.7.3";
+  name = pname + "-" + version;
 
   src = fetchurl {
     url = "mirror://pypi/p/pytest/${name}.tar.gz";

pkgs/development/python-modules/pytest/2_8.nix

···
 { stdenv, pkgs, buildPythonPackage, fetchurl, isPy26, argparse, py, selenium }:
 buildPythonPackage rec {
-  name = "pytest-2.8.7";
+  pname = "pytest";
+  version = "2.8.7";
+  name = pname + "-" + version;
 
   src = fetchurl {
     url = "mirror://pypi/p/pytest/${name}.tar.gz";

pkgs/development/python-modules/pytest/2_9.nix

···
 { stdenv, pkgs, buildPythonPackage, fetchurl, isPy26, argparse, py, selenium }:
 buildPythonPackage rec {
-  name = "pytest-2.9.2";
+  pname = "pytest";
+  version = "2.9.2";
+  name = pname + "-" + version;
 
   src = fetchurl {
     url = "mirror://pypi/p/pytest/${name}.tar.gz";

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

···
 { stdenv, buildPythonPackage, fetchPypi, isPy26, argparse, hypothesis, py
-, setuptools_scm
+, setuptools_scm, setuptools
 }:
 buildPythonPackage rec {
   version = "3.2.5";
   pname = "pytest";
-  name = "${pname}-${version}";
 
   preCheck = ''
     # don't test bash builtins
···
     sha256 = "6d5bd4f7113b444c55a3bbb5c738a3dd80d43563d063fc42dcb0aaefbdd78b81";
   };
 
-  buildInputs = [ hypothesis setuptools_scm ];
-  propagatedBuildInputs = [ py ]
+  checkInputs = [ hypothesis ];
+  buildInputs = [ setuptools_scm ];
+  propagatedBuildInputs = [ py setuptools ]
     ++ (stdenv.lib.optional isPy26 argparse);
 
   meta = with stdenv.lib; {

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

···
 { lib, buildPythonPackage, fetchFromGitHub, pytest, pytestrunner, pytestcov, pytestflakes, pytestpep8, sphinx, six }:
 
 buildPythonPackage rec {
-  name = "python-utils-${version}";
+  pname = "python-utils";
   version = "2.2.0";
+  name = pname + "-" + version;
 
   src = fetchFromGitHub {
     owner = "WoLpH";

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

···
 buildPythonPackage rec {
   pname = "python-fedora";
   version = "0.9.0";
-  name = "python-fedora-${version}";
+  name = pname + "-" + version;
 
   src = fetchPypi {
     inherit pname version;

pkgs/development/python-modules/rackspace-novaclient/default.nix

···
 { buildPythonPackage, fetchurl, isPy3k, requests, novaclient, six, lib }:
 let
 os-virtual-interfacesv2-python-novaclient-ext = buildPythonPackage rec {
-  name = "os_virtual_interfacesv2_python_novaclient_ext-0.20";
+  pname = "os_virtual_interfacesv2_python_novaclient_ext";
+  version = "0.20";
+  name = pname + "-" + version;
 
   src = fetchurl {
     url = "mirror://pypi/o/os-virtual-interfacesv2-python-novaclient-ext/${name}.tar.gz";
···
 };
 
 ip-associations-python-novaclient-ext = buildPythonPackage rec {
-  name = "ip_associations_python_novaclient_ext-0.2";
+  pname = "ip_associations_python_novaclient_ext";
+  version = "0.2";
+  name = pname + "-" + version;
 
   src = fetchurl {
     url = "mirror://pypi/i/ip_associations_python_novaclient_ext/${name}.tar.gz";
···
     description = "Adds Rackspace ip_associations support to python-novaclient";
   };
 };
-
 
 rackspace-auth-openstack = buildPythonPackage rec {
-  name = "rackspace-auth-openstack-1.3";
+  pname = "rackspace-auth-openstack";
+  version = "1.3";
+  name = pname + "-" + version;
 
   src = fetchurl {
     url = "mirror://pypi/r/rackspace-auth-openstack/${name}.tar.gz";
···
   };
 };
 rax-default-network-flags-python-novaclient-ext = buildPythonPackage rec {
-  name = "rax_default_network_flags_python_novaclient_ext-0.4.0";
+  pname = "rax_default_network_flags_python_novaclient_ext";
+  version = "0.4.0";
+  name = pname + "-" + version;
 
   src = fetchurl {
     url = "mirror://pypi/r/rax_default_network_flags_python_novaclient_ext/${name}.tar.gz";
···
   };
 };
 os-networksv2-python-novaclient-ext = buildPythonPackage rec {
-  name = "os_networksv2_python_novaclient_ext-0.26";
+  pname = "os_networksv2_python_novaclient_ext";
+  version = "0.26";
+  name = pname + "-" + version;
 
   src = fetchurl {
     url = "mirror://pypi/o/os_networksv2_python_novaclient_ext/${name}.tar.gz";
···
 };
 
 rax-scheduled-images-python-novaclient-ext = buildPythonPackage rec {
-  name = "rax_scheduled_images_python_novaclient_ext-0.3.1";
+  pname = "rax_scheduled_images_python_novaclient_ext";
+  version = "0.3.1";
+  name = pname + "-" + version;
 
   src = fetchurl {
     url = "mirror://pypi/r/rax_scheduled_images_python_novaclient_ext/${name}.tar.gz";
···
 };
 
 os-diskconfig-python-novaclient-ext = buildPythonPackage rec {
-  name = "os_diskconfig_python_novaclient_ext-0.1.3";
+  pname = "os_diskconfig_python_novaclient_ext";
+  version = "0.1.3";
+  name = pname + "-" + version;
 
   src = fetchurl {
     url = "mirror://pypi/o/os_diskconfig_python_novaclient_ext/${name}.tar.gz";
···
 
 in
 buildPythonPackage rec {
-  name = "rackspace-novaclient-2.1";
+  pname = "rackspace-novaclient";
+  version = "2.1";
+  name = pname + "-" + version;
 
   src = fetchurl {
     url = "mirror://pypi/r/rackspace-novaclient/${name}.tar.gz";

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

···
 { lib, buildPythonPackage, fetchurl, isPy3k, contextlib2 }:
 
 buildPythonPackage rec {
-  name = "raven-6.3.0";
+  pname = "raven";
+  version = "6.3.0";
+  name = pname + "-" + version;
 
   src = fetchurl {
     url = "mirror://pypi/r/raven/${name}.tar.gz";

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

···
 { stdenv, python }:
 
 stdenv.mkDerivation rec {
-  name = "python-recursive-pth-loader-1.0";
+  pname = "python-recursive-pth-loader";
+  version = "1.0";
+  name = pname + "-" + version;
 
   unpackPhase = "true";
 

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

···
 
 buildPythonPackage rec {
   pname = "restructuredtext_lint";
-  version = "1.1.1";
+  version = "1.1.2";
   name = "${pname}-${version}";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "167e8adaa5bdc30531ee91760d6c216b306a8a3372aad34b1f72d8adcc5e011e";
+    sha256 = "9201d354e22c27be61cf6d8212da6e10c875eec7ec8d1bdb1067b2a5ba931637";
   };
 
   checkInputs = [ nose flake8 pyyaml testtools ];

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

···
 { stdenv, fetchurl, buildPythonPackage, pyparsing, argparse, robotframework }:
 
 buildPythonPackage rec {
-  name = "robomachine-0.6";
+  pname = "robomachine";
+  version = "0.6";
+  name = pname + "-" + version;
 
   src = fetchurl {
     url = "mirror://pypi/R/RoboMachine/RoboMachine-0.6.tar.gz";

pkgs/development/python-modules/robotframework-ride/default.nix

···
 
 buildPythonPackage rec {
   version = "1.2.3";
-  name = "robotframework-ride-${version}";
+  pname = "robotframework-ride";
   disabled = isPy3k;
+  name = pname + "-" + version;
 
   src = fetchurl {
     url = "https://robotframework-ride.googlecode.com/files/${name}.tar.gz";

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

···
 
 buildPythonPackage rec {
   version = "3.0.2";
-  name = "robotframework-${version}";
+  pname = "robotframework";
   disabled = isPy3k;
+  name = pname + "-" + version;
 
   src = fetchurl {
     url = "mirror://pypi/r/robotframework/${name}.tar.gz";

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

···
 { stdenv, fetchurl, buildPythonPackage, isPy3k, isPyPy }:
 
 buildPythonPackage rec {
-  name = "scapy-2.2.0";
+  pname = "scapy";
+  version = "2.2.0";
+  name = pname + "-" + version;
 
   disabled = isPy3k || isPyPy;
 

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

···
 }:
 
 buildPythonPackage rec {
-  name = "selenium-3.6.0";
+  pname = "selenium";
+  version = "3.6.0";
+  name = pname + "-" + version;
+
   src = fetchurl {
     url = "mirror://pypi/s/selenium/${name}.tar.gz";
     sha256 = "15qpvz0bdwjvpcj11fm0rw6r5inr66sqw89ww50l025sbhf04qwm";
···
     license = licenses.asl20;
     maintainers = with maintainers; [ jraygauthier ];
   };
-}
+}

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

···
 }:
 
 buildPythonPackage rec {
-  name = "seqdiag-0.9.4";
+  pname = "seqdiag";
+  version = "0.9.5";
+  name = pname + "-" + version;
 
   src = fetchurl {
     url = "mirror://pypi/s/seqdiag/${name}.tar.gz";
-    sha256 = "1qa7d0m1wahvmrj95rxkb6128cbwd4w3gy8gbzncls66h46bifiz";
+    sha256 = "994402cb19fef77ee113d18810aa397a7290553cda5f900be2bb44e2c7742657";
   };
 
   buildInputs = [ pep8 nose unittest2 docutils ];

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

···
 # Should use buildPythonPackage here somehow
 stdenv.mkDerivation rec {
   pname = "setuptools";
-  version = "36.6.0";
+  version = "36.7.1";
   name = "${python.libPrefix}-${pname}-${version}";
 
   src = fetchPypi {
     inherit pname version;
     extension = "zip";
-    sha256 = "62074589522a798da243f47348f38020d55b6c945652e2f2c09d3a96299812b7";
+    sha256 = "543becf5d33d8989dc5222403997488e9dc3872bdecdabb0f57184ca253ec1e8";
   };
 
   buildInputs = [ python wrapPython unzip ];

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

···
 , python
 , fetchPypi
 , fetchFromGitHub
-, pytest 
+, pytest
 , cython
 , cymem
 , preshed
···
     version = "2017.04.05";
 
     src = fetchPypi {
-      inherit pname version;      
+      inherit pname version;
       sha256 = "0c95gf3jzz8mv52lkgq0h7sbasjwvdhghm4s0phmy5k9sr78f4fq";
     };
   };
 in buildPythonPackage rec {
-  name = "spacy-${version}";
+  pname = "spacy";
   version = "1.8.2";
+  name = pname + "-" + version;
 
   src = fetchFromGitHub {
     owner = "explosion";
     repo = "spaCy";
     rev = "v${version}";
-    sha256 = "0v3bmmar31a6968y4wl0lmgnc3829l2mnwd8s959m4pqw1y1w648";    
-  };  
+    sha256 = "0v3bmmar31a6968y4wl0lmgnc3829l2mnwd8s959m4pqw1y1w648";
+  };
 
   propagatedBuildInputs = [
    cython
···
   doCheck = false;
   # checkPhase = ''
   #   ${python.interpreter} -m pytest spacy/tests --vectors --models --slow
-  # '';  
-  
+  # '';
+
   meta = with stdenv.lib; {
     description = "Industrial-strength Natural Language Processing (NLP) with Python and Cython";
     homepage = https://github.com/explosion/spaCy;

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

···
 { lib, fetchurl, buildPythonPackage, numpy }:
 
 buildPythonPackage rec {
-  name = "sphfile-${version}";
+  pname = "sphfile";
   version = "1.0.0";
+  name = pname + "-" + version;
 
   src = fetchurl {
     url = "mirror://pypi/s/sphfile/${name}.tar.gz";

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

···
 
 buildPythonPackage rec {
   pname = "spotipy";
-  name = "spotipy-${version}";
   version = "2.4.4";
+  name = pname + "-" + version;
 
   src = fetchPypi {
     inherit pname version;

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

···
 }:
 
 buildPythonPackage rec {
-  name = "python-sybase-${version}";
+  pname = "python-sybase";
   version = "0.40pre2";
+  name = pname + "-" + version;
   disabled = isPy3k;
 
   src = fetchurl {

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

···
 { stdenv, buildPythonPackage, fetchFromGitHub, systemd, pkgconfig }:
 
 buildPythonPackage rec {
-  name = "python-systemd-${version}";
+  pname = "systemd";
   version = "234";
+  name = pname + "-" + version;
 
   src = fetchFromGitHub {
     owner = "systemd";

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

···
   };
 
 in buildPythonPackage (common // {
+  pname = "tensorflow";
+  version = common.version;
   name = "tensorflow-${common.version}";
 
   deps = stdenv.mkDerivation (common // {

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

···
 
 buildPythonPackage rec {
   pname = "testfixtures";
-  version = "5.3.0";
+  version = "5.3.1";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "1xfar653qmikwb94xj3f0xfp8dh2llxjsxipx1272d8qwl0aknnx";
+    sha256 = "670ade9410b7132278209e6a2e893caf098b040c4ba4d5ea848367a9c5588728";
   };
 
   checkInputs = [ mock manuel pytest sybil zope_component ];

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

···
     version = "1.0.1";
 
     src = fetchPypi {
-      inherit pname version;      
+      inherit pname version;
       sha256 = "17zajiw4mjbkkv6ahp3xf025qglkj0805m9s41c45zryzj6p2h39";
     };
 
     doCheck = false; # fails to import support from test
   };
 in buildPythonPackage rec {
-  name = "thinc-${version}";
+  pname = "thinc";
   version = "6.5.1";
+  name = pname + "-" + version;
 
   src = fetchFromGitHub {
     owner = "explosion";
     repo = "thinc";
     rev = "v${version}";
-    sha256 = "008kmjsvanh6qgnpvsn3qacfcyprxirxbw4yfd8flyg7mxw793ws";    
+    sha256 = "008kmjsvanh6qgnpvsn3qacfcyprxirxbw4yfd8flyg7mxw793ws";
   };
 
   propagatedBuildInputs = [
···
   ];
 
   doCheck = false;
-  
+
   # fails to import some modules
   # checkPhase = ''
   #   ${python.interpreter} -m pytest thinc/tests
   #   # cd thinc/tests
   #   # ${python.interpreter} -m unittest discover -p "*test*"
   # '';
-  
+
   meta = with stdenv.lib; {
     description = "Practical Machine Learning for NLP in Python";
     homepage = https://github.com/explosion/thinc;

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

···
 buildPythonPackage rec {
   pname = "tiros";
   name = "${pname}-${version}";
-  version = "1.0.39";
+  version = "1.0.40";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "10wh84lpl7k8i69hlxwrzp2lln63w2afv9l7ij7r3lqjwd0z0skr";
+    sha256 = "841ca13564e3cddfd1404cbc60b3433bcc1e31c2753ecea20d0ad68173b80169";
   };
 
   patchPhase = ''

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

···
 
   buildInputs = [ nose coverage glibcLocales flake8 ];
 
+  postPatch = ''
+    # Remove performance testing.
+    # Too sensitive for on Hydra.
+    rm tqdm/tests/tests_perf.py
+  '';
+
   LC_ALL="en_US.UTF-8";
 
   meta = {

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

···
 
   buildInputs = [ mock ];
 
-  propagatedBuildInputs = lib.optional (isPy27 || isPyPy) [ futures ];
+  propagatedBuildInputs = lib.optionals (isPy27 || isPyPy) [ futures ];
 
   patches = [
     ./tests.patch

pkgs/development/python-modules/u-msgpack-python/default.nix

···
 , python
 }:
 
-let
+buildPythonPackage rec {
   pname = "u-msgpack-python";
   version = "2.4.1";
-in buildPythonPackage rec {
   name = "${pname}-${version}";
 
   src = fetchurl {

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

···
 { stdenv, buildPythonPackage, isPy3k, fetchurl }:
 
 buildPythonPackage rec {
-  name = "umemcache-${version}";
+  pname = "umemcache";
   version = "1.6.3";
   disabled = isPy3k;
+  name = pname + "-" + version;
 
   src = fetchurl {
     url = "mirror://pypi/u/umemcache/${name}.zip";

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

···
 
 buildPythonPackage rec {
   pname = "uritools";
-  name = "uritools-${version}";
   version = "2.1.0";
+  name = pname + "-" + version;
 
   src = fetchPypi {
     inherit pname version;

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

···
    })
   ];
 
+  postPatch = ''
+    # Several tests keep failing on Hydra
+    rm urwid/tests/test_vterm.py
+  '';
+
   meta = with stdenv.lib; {
     description = "A full-featured console (xterm et al.) user interface library";
     homepage = http://excess.org/urwid;

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

···
 { stdenv, fetchurl, buildPythonPackage, pyusb }:
 
 buildPythonPackage rec {
-  name = "usbtmc-${version}";
+  pname = "usbtmc";
   version = "0.8";
+  name = pname + "-" + version;
 
   src = fetchurl {
     url = "https://github.com/python-ivi/python-usbtmc/archive/v${version}.tar.gz";

pkgs/development/python-modules/waitress-django/default.nix

···
 { buildPythonPackage, django_1_8, waitress }:
-buildPythonPackage {
-  name = "waitress-django";
+
+buildPythonPackage rec {
+  pname = "waitress-django";
+  version = "0.0.0";
+  name = pname;
+
   src = ./.;
   pythonPath = [ django_1_8 waitress ];
   doCheck = false;

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

···
 , pytest
 }:
 
-let
+buildPythonPackage rec {
   pname = "webencodings";
   version = "0.5.1";
-in buildPythonPackage rec {
   name = "${pname}-${version}";
 
   src = fetchurl {
···
     homepage = https://github.com/SimonSapin/python-webencodings;
     license = lib.licenses.bsd3;
   };
-}
+}

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

···
 buildPythonPackage rec {
   pname = "widgetsnbextension";
   name = "${pname}-${version}";
-  version = "3.0.6";
+  version = "3.0.8";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "3fbedb4ae0883f48af2397c65a8f9fbf8ed868f1808db70f8aa72f25d391fa9b";
+    sha256 = "a57e29e733b989e68fdd0f3d6927a3691763b39792591d573b95a89a5a12ec15";
   };
 
   propagatedBuildInputs = [ notebook ];

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

···
 assert wxGTK.unicode;
 
 buildPythonPackage rec {
-  name = "wxPython-${version}";
+  pname = "wxPython";
   version = "3.0.2.0";
+  name = pname + "-" + version;
 
   disabled = isPy3k || isPyPy;
   doCheck = false;

pkgs/development/r-modules/generic-builder.nix

···
   '';
 
   postFixup = ''
-    if test -e $out/nix-support/propagated-native-build-inputs; then
-        ln -s $out/nix-support/propagated-native-build-inputs $out/nix-support/propagated-user-env-packages
+    if test -e $out/nix-support/propagated-build-inputs; then
+        ln -s $out/nix-support/propagated-build-inputs $out/nix-support/propagated-user-env-packages
     fi
   '';
 

pkgs/development/tools/continuous-integration/gitlab-runner/default.nix

···
 { lib, buildGoPackage, fetchFromGitLab, fetchurl, go-bindata }:
 
 let
-  version = "10.1.0";
+  version = "10.2.0";
   # Gitlab runner embeds some docker images these are prebuilt for arm and x86_64
   docker_x86_64 = fetchurl {
     url = "https://gitlab-runner-downloads.s3.amazonaws.com/v${version}/docker/prebuilt-x86_64.tar.xz";
-    sha256 = "0h8fwqsr8ibd82jxq4pc9p8x7af0i8jyrrsj13p4daqhla0srxr4";
+    sha256 = "191yzh9k6ivj7mdfi5mv7wgbdcclb5q99rcbry70h064vzwfgkp6";
   };
 
   docker_arm = fetchurl {
     url = "https://gitlab-runner-downloads.s3.amazonaws.com/v${version}/docker/prebuilt-arm.tar.xz";
-    sha256 = "0bzj8zr6d5ab5bjlbw7q3iwn19ha8fksymrvw6cyzs4qacfsj54w";
+    sha256 = "1xvfsffwks5z74kxba6f4cilbabcsxhr0kskbxwczi90pn0rxsnn";
   };
 in
 buildGoPackage rec {
···
     owner = "gitlab-org";
     repo = "gitlab-runner";
     rev = "v${version}";
-    sha256 = "0knvjmxcscyr6v5b9vvyvm8w6p58a1h6nfcvf13dxp59psm71q00";
+    sha256 = "1psnajn4b3ym2fpvn6rizxqb093s78lvxcs3bysgrmf9q1ivf3a6";
   };
 
   patches = [ ./fix-shell-path.patch ];

pkgs/servers/monitoring/munin/default.nix

···
     find "$out/lib/plugins" -type f -print0 | xargs -0 -L1 \
         sed -i -e "s|/usr/bin/||g" -e "s|/usr/sbin/||g" -e "s|\<bc\>|${bc}/bin/bc|g"
 
-    if test -e $out/nix-support/propagated-native-build-inputs; then
-        ln -s $out/nix-support/propagated-native-build-inputs $out/nix-support/propagated-user-env-packages
+    if test -e $out/nix-support/propagated-build-inputs; then
+        ln -s $out/nix-support/propagated-build-inputs $out/nix-support/propagated-user-env-packages
     fi
 
     for file in "$out"/bin/munindoc "$out"/sbin/munin-* "$out"/lib/munin-* "$out"/www/cgi/*; do

pkgs/servers/x11/xorg/builder.sh

···
 
     echo "propagating requisites $requires"
 
+    if test -n "$crossConfig"; then
+        local pkgs=("${crossPkgs[@]}")
+    else
+        local pkgs=("${nativePkgs[@]}")
+    fi
     for r in $requires; do
-        if test -n "$crossConfig"; then
-            for p in "${crossPkgs[@]}"; do
-                if test -e $p/lib/pkgconfig/$r.pc; then
-                    echo "  found requisite $r in $p"
-                    propagatedBuildInputs="$propagatedBuildInputs $p"
-                fi
-            done
-        else
-            for p in "${nativePkgs[@]}"; do
-                if test -e $p/lib/pkgconfig/$r.pc; then
-                    echo "  found requisite $r in $p"
-                    propagatedNativeBuildInputs="$propagatedNativeBuildInputs $p"
-                fi
-            done
-        fi
+        for p in "${pkgs[@]}"; do
+            if test -e $p/lib/pkgconfig/$r.pc; then
+                echo "  found requisite $r in $p"
+                propagatedBuildInputs+=" $p"
+            fi
+        done
     done
 }
 

pkgs/stdenv/generic/setup.sh

···
 
 # printf unfortunately will print a trailing newline regardless
 printLines() {
-    [[ "$#" -gt 0 ]] || return 0
+    (( "$#" > 0 )) || return 0
     printf '%s\n' "$@"
 }
 
 printWords() {
-    [[ "$#" -gt 0 ]] || return 0
+    (( "$#" > 0 )) || return 0
     printf '%s ' "$@"
 }
 
···
 
 # Recursively find all build inputs.
 findInputs() {
-    local pkg="$1"
-    local var="$2"
-    local propagatedBuildInputsFile="$3"
+    local pkg="$1"; shift
+    local var="$1"; shift
+    local propagatedBuildInputsFiles=("$@")
 
     # TODO(@Ericson2314): Restore using associative array once Darwin
     # nix-shell doesn't use impure bash. This should replace the O(n)
···
         exit 1
     fi
 
-    if [ -f "$pkg/nix-support/$propagatedBuildInputsFile" ]; then
+    local file
+    for file in "${propagatedBuildInputsFiles[@]}"; do
+        file="$pkg/nix-support/$file"
+        [[ -f "$file" ]] || continue
+
         local pkgNext
-        for pkgNext in $(< "$pkg/nix-support/$propagatedBuildInputsFile"); do
-            findInputs "$pkgNext" "$var" "$propagatedBuildInputsFile"
+        for pkgNext in $(< "$file"); do
+            findInputs "$pkgNext" "$var" "${propagatedBuildInputsFiles[@]}"
         done
-    fi
+    done
 }
 
 # Add package to the future PATH and run setup hooks
···
     for i in ${nativeBuildInputs:-} ${buildInputs:-} \
              ${defaultNativeBuildInputs:-} ${defaultBuildInputs:-} \
              ${propagatedNativeBuildInputs:-} ${propagatedBuildInputs:-}; do
-        findInputs "$i" nativePkgs propagated-native-build-inputs
-    done
-
-    for i in "${nativePkgs[@]}"; do
-        activatePackage "$i"
+        findInputs "$i" nativePkgs propagated-native-build-inputs propagated-build-inputs
     done
 else
-    for i in ${buildInputs:-} ${defaultBuildInputs:-} ${propagatedBuildInputs:-}; do
-        findInputs "$i" crossPkgs propagated-build-inputs
-    done
-
     for i in ${nativeBuildInputs:-} ${defaultNativeBuildInputs:-} ${propagatedNativeBuildInputs:-}; do
         findInputs "$i" nativePkgs propagated-native-build-inputs
     done
-
-    for i in "${nativePkgs[@]}" "${crossPkgs[@]}"; do
-        activatePackage "$i"
+    for i in ${buildInputs:-} ${defaultBuildInputs:-} ${propagatedBuildInputs:-}; do
+        findInputs "$i" crossPkgs propagated-build-inputs
     done
 fi
+
+for i in ${nativePkgs+"${nativePkgs[@]}"} ${crossPkgs+"${crossPkgs[@]}"}; do
+    activatePackage "$i"
+done
 
 
 # Set the relevant environment variables to point to the build inputs
···
 
     # Propagate build inputs and setup hook into the development output.
 
-    if [ -z "${crossConfig:-}" ]; then
-        # Not cross-compiling - propagatedBuildInputs are handled identically to propagatedNativeBuildInputs
-        local propagated="$propagatedNativeBuildInputs"
-        if [ -n "${propagatedBuildInputs:-}" ]; then
-            propagated+="${propagated:+ }$propagatedBuildInputs"
-        fi
-        if [ -n "${propagated:-}" ]; then
-            mkdir -p "${!outputDev}/nix-support"
-            # shellcheck disable=SC2086
-            printWords $propagated > "${!outputDev}/nix-support/propagated-native-build-inputs"
-        fi
-    else
-        if [ -n "${propagatedBuildInputs:-}" ]; then
-            mkdir -p "${!outputDev}/nix-support"
-            # shellcheck disable=SC2086
-            printWords $propagatedBuildInputs > "${!outputDev}/nix-support/propagated-build-inputs"
-        fi
+    if [ -n "${propagatedBuildInputs:-}" ]; then
+        mkdir -p "${!outputDev}/nix-support"
+        # shellcheck disable=SC2086
+        printWords $propagatedBuildInputs > "${!outputDev}/nix-support/propagated-build-inputs"
+    fi
 
-        if [ -n "${propagatedNativeBuildInputs:-}" ]; then
-            mkdir -p "${!outputDev}/nix-support"
-            # shellcheck disable=SC2086
-            printWords $propagatedNativeBuildInputs > "${!outputDev}/nix-support/propagated-native-build-inputs"
-        fi
+    if [ -n "${propagatedNativeBuildInputs:-}" ]; then
+        mkdir -p "${!outputDev}/nix-support"
+        # shellcheck disable=SC2086
+        printWords $propagatedNativeBuildInputs > "${!outputDev}/nix-support/propagated-native-build-inputs"
     fi
+
 
     if [ -n "${setupHook:-}" ]; then
         mkdir -p "${!outputDev}/nix-support"

pkgs/tools/filesystems/ceph/generic.nix

···
     wrapProgram $out/sbin/ceph-create-keys ${wrapArgs}
     wrapProgram $out/sbin/ceph-disk ${wrapArgs}
 
-    # Bring in lib as a native build input
+    # Bring in lib as a run-time dependency
     mkdir -p $out/nix-support
-    echo "$lib" > $out/nix-support/propagated-native-build-inputs
+    echo "$lib" > $out/nix-support/propagated-build-inputs
 
     # Fix the python library loading
     find $lib/lib -name \*.pyc -or -name \*.pyd -exec rm {} \;

pkgs/tools/misc/system-config-printer/default.nix

···
 
   nativeBuildInputs = [ wrapGAppsHook ];
 
-  pythonPath = with pythonPackages;
-    [ pycups pycurl dbus-python pygobject3 requests pycairo pysmbc ];
+  pythonPath = with pythonPackages; requiredPythonModules [ pycups pycurl dbus-python pygobject3 requests pycairo pysmbc ];
 
   configureFlags =
     [ "--with-udev-rules"

pkgs/top-level/all-packages.nix

···
     # the hook to find catalogs is hidden by buildEnv
     postBuild = ''
       mkdir "$out/nix-support"
-      cp '${libxml2.dev}/nix-support/propagated-native-build-inputs' "$out/nix-support/"
+      cp '${libxml2.dev}/nix-support/propagated-build-inputs' "$out/nix-support/"
     '';
   };
 

pkgs/top-level/python-packages.nix

···
 
   callPackage = pkgs.newScope self;
 
+  namePrefix = python.libPrefix + "-";
+
   bootstrapped-pip = callPackage ../development/python-modules/bootstrapped-pip { };
-
-  mkPythonDerivation = makeOverridable( callPackage ../development/interpreters/python/mk-python-derivation.nix {
-  });
 
   # Derivations built with `buildPythonPackage` can already be overriden with `override`, `overrideAttrs`, and `overrideDerivation`.
   # This function introduces `overridePythonAttrs` and it overrides the call to `buildPythonPackage`.
···
       }
       else ff;
 
-  buildPythonPackage = makeOverridablePythonPackage (callPackage ../development/interpreters/python/build-python-package.nix {
-    inherit mkPythonDerivation;
+  buildPythonPackage = makeOverridablePythonPackage ( makeOverridable (callPackage ../development/interpreters/python/build-python-package.nix {
     inherit bootstrapped-pip;
     flit = self.flit;
-  });
+    # We want Python libraries to be named like e.g. "python3.6-${name}"
+    inherit namePrefix;
+    pythonModule = python;
+  }));
 
-  buildPythonApplication = args: buildPythonPackage ({namePrefix="";} // args );
+  buildPythonApplication = makeOverridablePythonPackage ( makeOverridable (callPackage ../development/interpreters/python/build-python-package.nix {
+    inherit bootstrapped-pip;
+    flit = self.flit;
+    namePrefix = "";
+    pythonModule = false;
+  }));
 
   graphiteVersion = "1.0.2";
 
···
         else if format == "setuptools" then fetchSource
         else throw "Unsupported kind ${kind}");
     in fetcher (builtins.removeAttrs attrs ["format"]) );
+
+  # Check whether a derivation provides a Python module.
+  hasPythonModule = drv: (hasAttr "pythonModule" drv) && ( (getAttr "pythonModule" drv) == python);
+
+  # Get list of required Python modules given a list of derivations.
+  requiredPythonModules = drvs: let
+    filterNull = list: filter (x: !isNull x) list;
+    conditionalGetRecurse = attr: condition: drv: let f = conditionalGetRecurse attr condition; in
+      (if (condition drv) then unique [drv]++(concatMap f (filterNull(getAttr attr drv))) else []);
+    _required = drv: conditionalGetRecurse "propagatedBuildInputs" hasPythonModule drv;
+  in [python] ++ (unique (concatMap _required (filterNull drvs)));
+
+  # Create a PYTHONPATH from a list of derivations. This function recurses into the items to find derivations
+  # providing Python modules.
+  makePythonPath = drvs: stdenv.lib.makeSearchPath python.sitePackages (requiredPythonModules drvs);
+
+  # Convert derivation to a Python module.
+  toPythonModule = drv:
+    drv.overrideAttrs( oldAttrs: {
+      # Use passthru in order to prevent rebuilds when possible.
+      passthru = (oldAttrs.passthru or {})// {
+        name = namePrefix + oldAttrs.name;
+        pythonModule = python;
+        pythonPath = [ ]; # Deprecated, for compatibility.
+      };
+    });
+
+  disabledIf = x: drv:
+    if x then throw "${removePrefix namePrefix (drv.pname or drv.name)} not supported for interpreter ${python.executable}" else drv;
 
 in {
 
-  inherit python bootstrapped-pip pythonAtLeast pythonOlder isPy26 isPy27 isPy33 isPy34 isPy35 isPy36 isPyPy isPy3k mkPythonDerivation buildPythonPackage buildPythonApplication;
+  inherit python bootstrapped-pip pythonAtLeast pythonOlder isPy26 isPy27 isPy33 isPy34 isPy35 isPy36 isPyPy isPy3k buildPythonPackage buildPythonApplication;
   inherit fetchPypi callPackage;
+  inherit hasPythonModule requiredPythonModules makePythonPath disabledIf;
 
   # helpers
 
···
 
   breathe = callPackage ../development/python-modules/breathe { };
 
-  browsermob-proxy = if ! isPy3k then
-    callPackage ../development/python-modules/browsermob-proxy {}
-  else throw "browsermob-proxy is not supported for ${python.executable}";
+  browsermob-proxy = disabledIf isPy3k (callPackage ../development/python-modules/browsermob-proxy {});
 
   bugseverywhere = callPackage ../applications/version-management/bugseverywhere {};
 
···
 
   pyamf = callPackage ../development/python-modules/pyamf { };
 
-  pyatspi = if isPy3k then callPackage ../development/python-modules/pyatspi { } else throw "pyatspi not supported for interpreter ${python.executable}";
+  pyatspi = disabledIf (!isPy3k) (callPackage ../development/python-modules/pyatspi { });
 
   pycairo = callPackage ../development/python-modules/pycairo { };
 
-  pycangjie = if isPy3k then callPackage ../development/python-modules/pycangjie { } else throw "pycangjie not supported for interpreter ${python.executable}";
+  pycangjie = disabledIf (!isPy3k) (callPackage ../development/python-modules/pycangjie { });
 
   pycrypto = callPackage ../development/python-modules/pycrypto { };
 
···
 
   PyChromecast = callPackage ../development/python-modules/pychromecast { };
 
-  pyexiv2 = if (!isPy3k) then callPackage ../development/python-modules/pyexiv2 {} else throw "pyexiv2 not supported for interpreter ${python.executable}";
+  pyexiv2 = disabledIf isPy3k (callPackage ../development/python-modules/pyexiv2 {});
 
   py3exiv2 = callPackage ../development/python-modules/py3exiv2 { };
 
···
 
   PyWebDAV = callPackage ../development/python-modules/pywebdav { };
 
-  pyxml = if !isPy3k then callPackage ../development/python-modules/pyxml{ } else throw "pyxml not supported for interpreter ${python.executable}";
+  pyxml = disabledIf isPy3k (callPackage ../development/python-modules/pyxml{ });
 
   relatorio = callPackage ../development/python-modules/relatorio { };
 
   pyzufall = callPackage ../development/python-modules/pyzufall { };
 
-  rhpl = if !isPy3k then callPackage ../development/python-modules/rhpl {} else throw "rhpl not supported for interpreter ${python.executable}";
+  rhpl = disabledIf isPy3k (callPackage ../development/python-modules/rhpl {});
 
   simpleeval = callPackage ../development/python-modules/simpleeval { };
 
···
 
   # Build boost for this specific Python version
   # TODO: use separate output for libboost_python.so
-  boost = pkgs.boost.override {
+  boost = toPythonModule (pkgs.boost.override {
     inherit (self) python numpy;
     enablePython = true;
-  };
+  });
 
   buttersink = buildPythonPackage rec {
     name = "buttersink-0.6.8";
···
     propagatedBuildInputs = with self; [ pyusb ];
   };
 
-  opencv = pkgs.opencv.override {
+  opencv = toPythonModule (pkgs.opencv.override {
     enablePython = true;
     pythonPackages = self;
-  };
+  });
 
-  opencv3 = pkgs.opencv3.override {
+  opencv3 = toPythonModule (pkgs.opencv3.override {
     enablePython = true;
     pythonPackages = self;
-  };
+  });
 
   openidc-client = callPackage ../development/python-modules/openidc-client/default.nix {};
 
···
 
   easy-thumbnails = callPackage ../development/python-modules/easy-thumbnails { };
 
-  eccodes = if (isPy27) then
-      (pkgs.eccodes.overrideAttrs (oldattrs: {
-    name = "${python.libPrefix}-" + oldattrs.name;
-  })).override {
-    enablePython = true;
-    pythonPackages = self;
-  } else throw "eccodes not supported for interpreter ${python.executable}";
+  eccodes = disabledIf (!isPy27)
+    (toPythonModule (pkgs.eccodes.override {
+      enablePython = true;
+      pythonPackages = self;
+    }));
 
   EditorConfig = buildPythonPackage rec {
     name = "EditorConfig-${version}";
···
 
   folium = callPackage ../development/python-modules/folium { };
 
-  fontforge = pkgs.fontforge.override {
+  fontforge = toPythonModule (pkgs.fontforge.override {
     withPython = true;
     inherit python;
-  };
+  });
 
   fonttools = callPackage ../development/python-modules/fonttools { };
 
···
     };
   };
 
-  gdal = (pkgs.gdal.overrideDerivation (oldattrs: {
-    name = "${python.libPrefix}-" + oldattrs.name;
-  })).override {
+  gdal = toPythonModule (pkgs.gdal.override {
     pythonPackages = self;
-  };
+  });
 
   gdrivefs = buildPythonPackage rec {
     version = "0.14.8";
···
     };
   };
 
-  grib-api = if (isPy27) then
-      (pkgs.grib-api.overrideAttrs (oldattrs: {
-    name = "${python.libPrefix}-" + oldattrs.name;
-  })).override {
-    enablePython = true;
-    pythonPackages = self;
-  } else throw "grib-api not supported for interpreter ${python.executable}";
+  grib-api = disabledIf (!isPy27) (toPythonModule
+    (pkgs.grib-api.override {
+      enablePython = true;
+      pythonPackages = self;
+    }));
 
   gspread = buildPythonPackage rec {
     version = "0.2.3";
···
     inherit (pkgs) libsodium;
   };
 
-  libplist = if isPy3k then throw "libplist not supported for interpreter ${python.executable}" else
-    (pkgs.libplist.override{python2Packages=self; }).py;
+  libplist = disabledIf isPy3k
+    (toPythonModule (pkgs.libplist.override{python2Packages=self; })).py;
 
-  libxml2 = if isPy3k then throw "libxml2 not supported for interpreter ${python.executable}" else
-    (pkgs.libxml2.override{pythonSupport=true; python2=python;}).py;
+  libxml2 = disabledIf isPy3k
+    (toPythonModule (pkgs.libxml2.override{pythonSupport=true; python2=python;})).py;
 
-  libxslt = if isPy3k then throw "libxslt not supported for interpreter ${python.executable}" else
-    (pkgs.libxslt.override{pythonSupport=true; python2=python; inherit (self) libxml2;}).py;
+  libxslt = disabledIf isPy3k
+    (toPythonModule (pkgs.libxslt.override{pythonSupport=true; python2=python; inherit (self) libxml2;})).py;
 
   limnoria = buildPythonPackage rec {
     name = "limnoria-${version}";
···
     fuse = pkgs.fuse;  # use "real" fuse, not the python module
   };
 
-  locustio = buildPythonPackage rec {
-    name = "locustio-0.7.2";
-
-    src = pkgs.fetchurl {
-      url = "mirror://pypi/l/locustio/${name}.tar.gz";
-      sha256 = "c9ca6fdfe6a6fb187a3d54ddf9b1518196348e8f20537f0a14ca81a264ffafa2";
-    };
-
-    propagatedBuildInputs = [ self.msgpack self.requests self.flask self.gevent self.pyzmq ];
-    buildInputs = [ self.mock self.unittest2 ];
-
-    meta = {
-      homepage = http://locust.io/;
-      description = "A load testing tool";
-    };
-  };
+  locustio = callPackage ../development/python-modules/locustio { };
 
   llvmlite = callPackage ../development/python-modules/llvmlite {llvm=pkgs.llvm_4;};
 
···
 
   psd-tools = callPackage ../development/python-modules/psd-tools { };
 
-  psutil = buildPythonPackage rec {
-    name = "psutil-${version}";
-    version = "4.3.0";
+  psutil = callPackage ../development/python-modules/psutil { };
 
-    src = pkgs.fetchurl {
-      url = "mirror://pypi/p/psutil/${name}.tar.gz";
-      sha256 = "1w4r09fvn6kd80m5mx4ws1wz100brkaq6hzzpwrns8cgjzjpl6c6";
-    };
-
-    # Certain tests fail due to being in a chroot.
-    # See also the older issue: https://code.google.com/p/psutil/issues/detail?id=434
-    doCheck = false;
-
-    buildInputs = with self; [ mock ] ++ optionals stdenv.isDarwin [ pkgs.darwin.IOKit ];
-
-    meta = {
-      description = "Process and system utilization information interface for python";
-      homepage = https://github.com/giampaolo/psutil;
-    };
-  };
-
-  psutil_1 = self.psutil.overrideDerivation (self: rec {
-    name = "psutil-1.2.1";
-    src = pkgs.fetchurl {
-      url = "mirror://pypi/p/psutil/${name}.tar.gz";
+  psutil_1 = self.psutil.overrideAttrs (oldAttrs: rec {
+    name = "${oldAttrs.pname}-${version}";
+    version = "1.2.1";
+    src = oldAttrs.src.override {
+      inherit version;
       sha256 = "0ibclqy6a4qmkjhlk3g8jhpvnk0v9aywknc61xm3hfi5r124m3jh";
     };
   });
···
     };
   };
 
-  qscintilla = if isPy3k || isPyPy
-    then throw "qscintilla-${pkgs.qscintilla.version} not supported for interpreter ${python.executable}"
-    else buildPythonPackage rec {
+  qscintilla = disabledIf (isPy3k || isPyPy)
+    (buildPythonPackage rec {
       # TODO: Qt5 support
       name = "qscintilla-${version}";
       version = pkgs.qscintilla.version;
···
         maintainers = with maintainers; [ danbst ];
         platforms = platforms.linux;
       };
-    };
+    });
 
 
   qserve = buildPythonPackage rec {
···
   };
 
   readme_renderer = callPackage ../development/python-modules/readme_renderer { };
+
+  rivet = disabledIf isPy3k (toPythonModule (pkgs.rivet.override {
+    python2 = python;
+  }));
 
   rjsmin = callPackage ../development/python-modules/rjsmin { };
 
···
 
   rply = callPackage ../development/python-modules/rply/default.nix {};
 
-  rpm = (pkgs.rpm.override{inherit python;});
+  rpm = toPythonModule (pkgs.rpm.override{inherit python;});
 
   rpmfluff = callPackage ../development/python-modules/rpmfluff {};
 
···
   };
 
   # For backwards compatibility. Please use nixpkgs.udiskie instead.
-  udiskie = pkgs.udiskie.override { pythonPackages = self; };
+  udiskie = toPythonModule (pkgs.udiskie.override { pythonPackages = self; });
 
   # Should be bumped along with EFL!
   pythonefl = buildPythonPackage rec {
···
   ROPGadget = callPackage ../development/python-modules/ROPGadget { };
 
   # We need "normal" libxml2 and not the python package by the same name.
-  pywbem = if !(isPy36)
-    then callPackage ../development/python-modules/pywbem { libxml2 = pkgs.libxml2; }
-    else throw "pywbem not supported for interpreter ${python.executable}";
+  pywbem = disabledIf isPy36
+    (callPackage ../development/python-modules/pywbem { libxml2 = pkgs.libxml2; });
 
   unicorn = callPackage ../development/python-modules/unicorn { };
 
···
 
   zeep = callPackage ../development/python-modules/zeep { };
 
-  zeitgeist = if isPy3k then throw "zeitgeist not supported for interpreter ${python.executable}" else
-    (pkgs.zeitgeist.override{python2Packages=self;}).py;
+  zeitgeist = disabledIf isPy3k
+    (toPythonModule (pkgs.zeitgeist.override{python2Packages=self;})).py;
 
   zeroconf = callPackage ../development/python-modules/zeroconf { };