* buildPythonPackage: added an argument `pythonPath' to specify Python

  dependencies that are *not* propagated to the user environment
  (as opposed to `propagatedBuildInputs').  For instance, if you
  install `iotop', you typically don't want its Python dependencies
  polluting the user environment.
  
* buildPythonPackage: some cleanup (e.g. use function argument
  defaults instead of `if attrs ? foo then attrs.foo else []').

svn path=/nixpkgs/branches/modular-python/; revision=26571

2 files changed, 77 insertions, 72 deletions

diff --git a/pkgs/development/python-modules/generic/default.nix b/pkgs/development/python-modules/generic/default.nix
index 9dad415d835..1152a0aa447 100644
--- a/pkgs/development/python-modules/generic/default.nix
+++ b/pkgs/development/python-modules/generic/default.nix
@@ -5,46 +5,40 @@
 
 { python, setuptools, makeWrapper, lib }:
 
-{ name, namePrefix ? "python-", src, meta, patches ? []
-, installCommand ? ""
-, doCheck ? true, checkPhase ? "python setup.py test"
-, postInstall ? ""
-, ... } @ attrs:
+{ name, namePrefix ? "python-"
 
-let
-    defaultInstallCommand = ''easy_install --prefix="$out" .'';
+, buildInputs ? []
 
-    # Return the list of recursively propagated build inputs of PKG.
-    recursiveBuildInputs =
-      pkg:
-        [ pkg ] ++
-        (if pkg ? propagatedBuildNativeInputs
-         then lib.concatLists (map recursiveBuildInputs
-                                   pkg.propagatedBuildNativeInputs)
-         else []);
+, # List of packages that should be added to the PYTHONPATH
+  # environment variable in programs built by this function.  Packages
+  # in the standard `propagatedBuildInputs' variable are also added.
+  # The difference is that `pythonPath' is not propagated to the user
+  # environment.  This is preferrable for programs because it doesn't
+  # pollute the user environment.
+  pythonPath ? []
 
-in
+, installCommand ?
+    ''
+      easy_install --prefix="$out" .
+    ''
+    
+, buildPhase ? "true"
 
-python.stdenv.mkDerivation (
-  # Keep extra attributes from ATTR, e.g., `patchPhase', etc.
-  attrs
+, doCheck ? true, checkPhase ? "python setup.py test"
 
-  //
+, postInstall ? ""
 
-  (rec {
-  inherit src meta patches doCheck checkPhase;
+, ... } @ attrs:
 
-  name = namePrefix + attrs.name;
+# Keep extra attributes from ATTR, e.g., `patchPhase', etc.
+python.stdenv.mkDerivation (attrs // {
+  inherit doCheck buildPhase checkPhase;
 
-  buildInputs = [ python setuptools makeWrapper ] ++
-    (if attrs ? buildInputs then attrs.buildInputs else []);
+  name = namePrefix + name;
 
-  propagatedBuildInputs = [ setuptools ] ++
-    (if attrs ? propagatedBuildInputs
-     then attrs.propagatedBuildInputs
-     else []);
+  buildInputs = [ python makeWrapper setuptools ] ++ buildInputs ++ pythonPath;
 
-  buildPhase = "true";
+  pythonPath = [ setuptools] ++ pythonPath;
 
   # XXX: Should we run `easy_install --always-unzip'?  It doesn't seem
   # to have a noticeable impact on small scripts.
@@ -53,49 +47,60 @@ python.stdenv.mkDerivation (
 
     echo "installing \`${name}' with \`easy_install'..."
     export PYTHONPATH="$out/lib/${python.libPrefix}/site-packages:$PYTHONPATH"
-    ${if installCommand == "" then defaultInstallCommand else installCommand}
+    ${installCommand}
 
     ${postInstall}
   '';
 
-  postFixup = ''
-    # Wrap scripts that are under `{s,}bin/' so that they get the right
-    # $PYTHONPATH.
-    for i in "$out/bin/"* "$out/sbin/"*
-    do
-      if head -n1 "$i" | grep -q "${python}"
-      then
-          echo "wrapping \`$i'..."
-
-          # Compute a $PATH prefix for the program.
-          program_PATH=""
-          ${lib.concatStrings
-            (map (path:
-                  ''if [ -d "${path}/bin" ]
-                    then
-                        program_PATH="${path}/bin'' + "\$" + ''{program_PATH:+:}$program_PATH"
-                    fi
-                   '')
-                 (lib.concatMap recursiveBuildInputs propagatedBuildInputs))}
-
-          wrapProgram "$i"                          \
-            --prefix PYTHONPATH ":"                 \
-            ${lib.concatStringsSep ":"
-               ([ "$out/lib/${python.libPrefix}/site-packages" ] ++
-                (map (path: path + "/lib/${python.libPrefix}/site-packages")
-                     (lib.concatMap recursiveBuildInputs
-                                    propagatedBuildInputs)))} \
-            --prefix PATH ":" "$program_PATH"
-
+  postFixup =
+    ''
+      declare -A pythonPathsSeen
+    
+      addToPythonPath() {
+          local dir="$1"
+          if [ -n "''${pythonPathsSeen[$dir]}" ]; then return; fi
+          pythonPathsSeen[$dir]=1
+          addToSearchPath program_PYTHONPATH $dir/lib/${python.libPrefix}/site-packages
+          addToSearchPath program_PATH $dir/bin
+          local prop="$dir/nix-support/propagated-build-native-inputs"
+          if [ -e $prop ]; then
+              local i
+              for i in $(cat $prop); do
+                  addToPythonPath $i
+              done
+          fi
+      }
+    
+      wrapPythonPrograms() {
+          local dir="$1"
+          local pythonPath="$2"
+          local i
+
+          pythonPathsSeen=()
+          program_PYTHONPATH=
+          program_PATH=
+          for i in $pythonPath; do
+              addToPythonPath $i
+          done
+
+          for i in $(find "$out" -type f -perm +0100); do
+              if head -n1 "$i" | grep -q "${python}"; then
+                  echo "wrapping \`$i'..."
+                  wrapProgram "$i" \
+                    --prefix PYTHONPATH ":" $program_PYTHONPATH \
+                    --prefix PATH ":" $program_PATH
+              fi
+          done
+      }
+
+      wrapPythonPrograms $out "$out $pythonPath"
+
+      # If a user installs a Python package, she probably also wants its
+      # dependencies in the user environment (since Python modules don't
+      # have something like an RPATH, so the only way to find the
+      # dependencies is to have them in the PYTHONPATH variable).
+      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
-    done
-
-    # If a user installs a Python package, she probably also wants its
-    # dependencies in the user environment (since Python modules don't
-    # have something like an RPATH, so the only way to find the
-    # dependencies is to have them in the PYTHONPATH variable).
-    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
-  '';
-}))
+    '';
+})
diff --git a/pkgs/os-specific/linux/iotop/default.nix b/pkgs/os-specific/linux/iotop/default.nix
index 41d07dd4146..e394b612388 100644
--- a/pkgs/os-specific/linux/iotop/default.nix
+++ b/pkgs/os-specific/linux/iotop/default.nix
@@ -9,7 +9,7 @@ buildPythonPackage rec {
     sha256 = "1dfvw3khr2rvqllvs9wad9ca3ld4i7szqf0ibq87rn36ickrf3ll";
   };
 
-  propagatedBuildInputs = [ pythonPackages.curses ];
+  pythonPath = [ pythonPackages.curses ];
 
   doCheck = false;