Merge master into haskell-updates

Do pay attention to passing in the right Python version!

#### `mkPythonMetaPackage` function {#mkpythonmetapackage-function}

This will create a meta package containing [metadata files](https://packaging.python.org/en/latest/specifications/recording-installed-packages/) to satisfy a dependency on a package, without it actually having been installed into the environment.

In nixpkgs this is used to package Python packages with split binary/source distributions such as [psycopg2](https://pypi.org/project/psycopg2/)/[psycopg2-binary](https://pypi.org/project/psycopg2-binary/).

```nix

mkPythonMetaPackage {

  pname = "psycopg2-binary";

  inherit (psycopg2) optional-dependencies version;

  dependencies = [ psycopg2 ];

  meta = {

    inherit (psycopg2.meta) description homepage;

  };

}

```

#### `python.buildEnv` function {#python.buildenv-function}

Python environments can be created using the low-level `pkgs.buildEnv` function.

      ]);

    };

  /**

    `importApply file arg :: Path -> a -> Module`,  where `import file :: a -> Module`

    `importApply` imports a Nix expression file much like the module system would,

    after passing an extra positional argument to the function in the file.

    This function should be used when declaring a module in a file that refers to

    values from a different scope, such as that in a flake.

    It solves the problems of alternative solutions:

    - While `importApply file arg` is _mostly_ equivalent to

      `import file arg`, the latter returns a module without a location,

      as `import` only returns the contained expression. This leads to worse

      error messages.

    - Using `specialArgs` to provide arguments to all modules. This effectively

      creates an incomplete module, and requires the user of the module to

      manually pass the `specialArgs` to the configuration, which is error-prone,

      verbose, and unnecessary.

    The nix file must contain a function that returns a module.

    A module may itself be a function, so the file is often a function with two

    positional arguments instead of one. See the example below.

    This function does not add support for deduplication and `disabledModules`,

    although that could be achieved by wrapping the returned module and setting

    the `_key` module attribute.

    The reason for this omission is that the file path is not guaranteed to be

    a unique identifier for the module, as two instances of the module may

    reference different `arg`s in their closures.

    Example

        # lib.nix

        imports = [

          (lib.modules.importApply ./module.nix { bar = bar; })

        ];

        # module.nix

        { bar }:

        { lib, config, ... }:

        {

          options = ...;

          config = ... bar ...;

        }

  */

  importApply =

    modulePath: staticArg:

      lib.setDefaultModuleLocation modulePath (import modulePath staticArg);

  /* Use this function to import a JSON file as NixOS configuration.

     modules.importJSON :: path -> attrs

    filterOverrides'

    fixMergeModules

    fixupOptionType  # should be private?

    importApply

    importJSON

    importTOML

    mergeDefinitions

checkConfigOutput '^true$' "$@" ./define-enable.nix ./define-attrsOfSub-foo-if-enable.nix

checkConfigOutput '^true$' "$@" ./define-enable.nix ./define-attrsOfSub-foo-enable-if.nix

# Check importApply

checkConfigOutput '"abc"' config.value ./importApply.nix

# importApply does not set a key.

# Disabling the function file is not sufficient, because importApply can't reasonably assume that the key is unique.

# e.g. user may call it multiple times with different arguments and expect each of the module to apply.

# While this is excusable for the disabledModules aspect, it is not for the deduplication of modules.

checkConfigOutput '"abc"' config.value ./importApply-disabling.nix

# Check disabledModules with config definitions and option declarations.

set -- config.enable ./define-enable.nix ./declare-enable.nix

checkConfigOutput '^true$' "$@"

{

  imports = [ ./importApply.nix ];

  disabledModules = [ ./importApply-function.nix ];

}

{ foo }:

{ lib, config, ... }:

{

  value = foo;

}