commit ea4da560fff51fb70b6cc7a37fb1275264d904b5 · pyrox.dev/nixpkgs

+1 -1

doc/contributing/coding-conventions.chapter.md

···

       181
       181
        
         rev = "${version}";

     

       182
       182
        
         ```

     

       183
       183
        
       

     

       184
       184
       -
       - Filling lists condionally _should_ be done with `lib.optional(s)` instead of using `if cond then [ ... ] else null` or `if cond then [ ... ] else [ ]`.

     

       184
       184
       +
       - Building lists conditionally _should_ be done with `lib.optional(s)` instead of using `if cond then [ ... ] else null` or `if cond then [ ... ] else [ ]`.

     

       185
       185
        
       

     

       186
       186
        
         ```nix

     

       187
       187
        
         buildInputs = lib.optional stdenv.isDarwin iconv;

+20 -7

nixos/doc/manual/from_md/release-notes/rl-2111.section.xml

···

       1190
       1190
        
                 dropped because it was EOLed by upstream in 2021-10.

     

       1191
       1191
        
               </para>

     

       1192
       1192
        
             </listitem>

     

       1193
       1193
       +
             <listitem>

     

       1194
       1194
       +
               <para>

     

       1195
       1195
       +
                 The <literal>virtualisation.pathsInNixDB</literal> option was

     

       1196
       1196
       +
                 renamed

     

       1197
       1197
       +
                 <link xlink:href="options.html#opt-virtualisation.additionalPaths"><literal>virtualisation.additionalPaths</literal></link>.

     

       1198
       1198
       +
               </para>

     

       1199
       1199
       +
             </listitem>

     

       1193
       1200
        
           </itemizedlist>

     

       1194
       1201
        
         </section>

     

       1195
       1202
        
         <section xml:id="sec-release-21.11-notable-changes">

     
···

       1213
       1220
        
               <para>

     

       1214
       1221
        
                 In NixOS virtual machines (QEMU), the

     

       1215
       1222
        
                 <literal>virtualisation</literal> module has been updated with

     

       1216
       1216
       -
                 new options to configure:

     

       1223
       1223
       +
                 new options:

     

       1217
       1224
        
               </para>

     

       1218
       1225
        
               <itemizedlist spacing="compact">

     

       1219
       1226
        
                 <listitem>

     

       1220
       1227
        
                   <para>

     

       1221
       1221
       -
                     IPv4 port forwarding

     

       1222
       1222
       -
                     (<link xlink:href="options.html#opt-virtualisation.forwardPorts"><literal>virtualisation.forwardPorts</literal></link>),

     

       1228
       1228
       +
                     <link xlink:href="options.html#opt-virtualisation.forwardPorts"><literal>forwardPorts</literal></link>

     

       1229
       1229
       +
                     to configure IPv4 port forwarding,

     

       1230
       1230
       +
                   </para>

     

       1231
       1231
       +
                 </listitem>

     

       1232
       1232
       +
                 <listitem>

     

       1233
       1233
       +
                   <para>

     

       1234
       1234
       +
                     <link xlink:href="options.html#opt-virtualisation.sharedDirectories"><literal>sharedDirectories</literal></link>

     

       1235
       1235
       +
                     to set up shared host directories,

     

       1223
       1236
        
                   </para>

     

       1224
       1237
        
                 </listitem>

     

       1225
       1238
        
                 <listitem>

     

       1226
       1239
        
                   <para>

     

       1227
       1227
       -
                     shared host directories

     

       1228
       1228
       -
                     (<link xlink:href="options.html#opt-virtualisation.sharedDirectories"><literal>virtualisation.sharedDirectories</literal></link>),

     

       1240
       1240
       +
                     <link xlink:href="options.html#opt-virtualisation.resolution"><literal>resolution</literal></link>

     

       1241
       1241
       +
                     to set the screen resolution,

     

       1229
       1242
        
                   </para>

     

       1230
       1243
        
                 </listitem>

     

       1231
       1244
        
                 <listitem>

     

       1232
       1245
        
                   <para>

     

       1233
       1233
       -
                     screen resolution

     

       1234
       1234
       -
                     (<link xlink:href="options.html#opt-virtualisation.resolution"><literal>virtualisation.resolution</literal></link>).

     

       1246
       1246
       +
                     <link xlink:href="options.html#opt-virtualisation.useNixStoreImage"><literal>useNixStoreImage</literal></link>

     

       1247
       1247
       +
                     to use a disk image for the Nix store instead of 9P.

     

       1235
       1248
        
                   </para>

     

       1236
       1249
        
                 </listitem>

     

       1237
       1250
        
               </itemizedlist>

+8 -4

nixos/doc/manual/release-notes/rl-2111.section.md

···

       366
       366
        
       

     

       367
       367
        
       - Nextcloud 20 (`pkgs.nextcloud20`) has been dropped because it was EOLed by upstream in 2021-10.

     

       368
       368
        
       

     

       369
       369
       +
       - The `virtualisation.pathsInNixDB` option was renamed

     

       370
       370
       +
         [`virtualisation.additionalPaths`](options.html#opt-virtualisation.additionalPaths).

     

       371
       371
       +
       

     

       369
       372
        
       ## Other Notable Changes {#sec-release-21.11-notable-changes}

     

       370
       373
        
       

     

       371
       374
        
       

     

       372
       375
        
       - The linux kernel package infrastructure was moved out of `all-packages.nix`, and restructured. Linux related functions and attributes now live under the `pkgs.linuxKernel` attribute set.

     

       373
       376
        
         In particular the versioned `linuxPackages_*` package sets (such as `linuxPackages_5_4`) and kernels from `pkgs` were moved there and now live under `pkgs.linuxKernel.packages.*`. The unversioned ones (such as `linuxPackages_latest`) remain untouched.

     

       374
       377
        
       

     

       375
       375
       -
       - In NixOS virtual machines (QEMU), the `virtualisation` module has been updated with new options to configure:

     

       376
       376
       -
           - IPv4 port forwarding ([`virtualisation.forwardPorts`](options.html#opt-virtualisation.forwardPorts)),

     

       377
       377
       -
           - shared host directories ([`virtualisation.sharedDirectories`](options.html#opt-virtualisation.sharedDirectories)),

     

       378
       378
       -
           - screen resolution ([`virtualisation.resolution`](options.html#opt-virtualisation.resolution)).

     

       378
       378
       +
       - In NixOS virtual machines (QEMU), the `virtualisation` module has been updated with new options:

     

       379
       379
       +
           - [`forwardPorts`](options.html#opt-virtualisation.forwardPorts) to configure IPv4 port forwarding,

     

       380
       380
       +
           - [`sharedDirectories`](options.html#opt-virtualisation.sharedDirectories) to set up shared host directories,

     

       381
       381
       +
           - [`resolution`](options.html#opt-virtualisation.resolution) to set the screen resolution,

     

       382
       382
       +
           - [`useNixStoreImage`](options.html#opt-virtualisation.useNixStoreImage) to use a disk image for the Nix store instead of 9P.

     

       379
       383
        
       

     

       380
       384
        
         In addition, the default [`msize`](options.html#opt-virtualisation.msize) parameter in 9P filesystems (including /nix/store and all shared directories) has been increased to 16K for improved performance.

     

       381
       385

+65 -23

nixos/lib/make-disk-image.nix

···

       44
       44
        
         #   most likely fails as GRUB will probably refuse to install.

     

       45
       45
        
         partitionTableType ? "legacy"

     

       46
       46
        
       

     

       47
       47
       +
       , # Whether to invoke `switch-to-configuration boot` during image creation

     

       48
       48
       +
         installBootLoader ? true

     

       49
       49
       +
       

     

       47
       50
        
       , # The root file system type.

     

       48
       51
        
         fsType ? "ext4"

     

       49
       52
        
       

     

       50
       53
        
       , # Filesystem label

     

       51
       51
       -
         label ? "nixos"

     

       54
       54
       +
         label ? if onlyNixStore then "nix-store" else "nixos"

     

       52
       55
        
       

     

       53
       56
        
       , # The initial NixOS configuration file to be copied to

     

       54
       57
        
         # /etc/nixos/configuration.nix.

     
···

       56
       59
        
       

     

       57
       60
        
       , # Shell code executed after the VM has finished.

     

       58
       61
        
         postVM ? ""

     

       62
       62
       +
       

     

       63
       63
       +
       , # Copy the contents of the Nix store to the root of the image and

     

       64
       64
       +
         # skip further setup. Incompatible with `contents`,

     

       65
       65
       +
         # `installBootLoader` and `configFile`.

     

       66
       66
       +
         onlyNixStore ? false

     

       59
       67
        
       

     

       60
       68
        
       , name ? "nixos-disk-image"

     

       61
       69
        
       

     

       62
       70
        
       , # Disk image format, one of qcow2, qcow2-compressed, vdi, vpc, raw.

     

       63
       71
        
         format ? "raw"

     

       72
       72
       +
       

     

       73
       73
       +
       , # Whether a nix channel based on the current source tree should be

     

       74
       74
       +
         # made available inside the image. Useful for interactive use of nix

     

       75
       75
       +
         # utils, but changes the hash of the image when the sources are

     

       76
       76
       +
         # updated.

     

       77
       77
       +
         copyChannel ? true

     

       78
       78
       +
       

     

       79
       79
       +
       , # Additional store paths to copy to the image's store.

     

       80
       80
       +
         additionalPaths ? []

     

       64
       81
        
       }:

     

       65
       82
        
       

     

       66
       83
        
       assert partitionTableType == "legacy" || partitionTableType == "legacy+gpt" || partitionTableType == "efi" || partitionTableType == "hybrid" || partitionTableType == "none";

     
···

       71
       88
        
                (attrs: ((attrs.user  or null) == null)

     

       72
       89
        
                     == ((attrs.group or null) == null))

     

       73
       90
        
                contents;

     

       91
       91
       +
       assert onlyNixStore -> contents == [] && configFile == null && !installBootLoader;

     

       74
       92
        
       

     

       75
       93
        
       with lib;

     

       76
       94
        
       

     
···

       163
       181
        
         users   = map (x: x.user  or "''") contents;

     

       164
       182
        
         groups  = map (x: x.group or "''") contents;

     

       165
       183
        
       

     

       166
       166
       -
         closureInfo = pkgs.closureInfo { rootPaths = [ config.system.build.toplevel channelSources ]; };

     

       184
       184
       +
         basePaths = [ config.system.build.toplevel ]

     

       185
       185
       +
           ++ lib.optional copyChannel channelSources;

     

       186
       186
       +
       

     

       187
       187
       +
         additionalPaths' = subtractLists basePaths additionalPaths;

     

       188
       188
       +
       

     

       189
       189
       +
         closureInfo = pkgs.closureInfo {

     

       190
       190
       +
           rootPaths = basePaths ++ additionalPaths';

     

       191
       191
       +
         };

     

       167
       192
        
       

     

       168
       193
        
         blockSize = toString (4 * 1024); # ext4fs block size (not block device sector size)

     

       169
       194
        
       

     
···

       251
       276
        
           chmod 755 "$TMPDIR"

     

       252
       277
        
           echo "running nixos-install..."

     

       253
       278
        
           nixos-install --root $root --no-bootloader --no-root-passwd \

     

       254
       254
       -
             --system ${config.system.build.toplevel} --channel ${channelSources} --substituters ""

     

       279
       279
       +
             --system ${config.system.build.toplevel} \

     

       280
       280
       +
             ${if copyChannel then "--channel ${channelSources}" else "--no-channel-copy"} \

     

       281
       281
       +
             --substituters ""

     

       282
       282
       +
       

     

       283
       283
       +
           ${optionalString (additionalPaths' != []) ''

     

       284
       284
       +
             nix copy --to $root --no-check-sigs ${concatStringsSep " " additionalPaths'}

     

       285
       285
       +
           ''}

     

       255
       286
        
       

     

       256
       287
        
           diskImage=nixos.raw

     

       257
       288
        
       

     
···

       320
       351
        
           ''}

     

       321
       352
        
       

     

       322
       353
        
           echo "copying staging root to image..."

     

       323
       323
       -
           cptofs -p ${optionalString (partitionTableType != "none") "-P ${rootPartition}"} -t ${fsType} -i $diskImage $root/* / ||

     

       354
       354
       +
           cptofs -p ${optionalString (partitionTableType != "none") "-P ${rootPartition}"} \

     

       355
       355
       +
                  -t ${fsType} \

     

       356
       356
       +
                  -i $diskImage \

     

       357
       357
       +
                  $root${optionalString onlyNixStore builtins.storeDir}/* / ||

     

       324
       358
        
             (echo >&2 "ERROR: cptofs failed. diskSize might be too small for closure."; exit 1)

     

       325
       359
        
         '';

     

       326
       326
       -
       in pkgs.vmTools.runInLinuxVM (

     

       327
       327
       -
         pkgs.runCommand name

     

       328
       328
       -
           { preVM = prepareImage;

     

       360
       360
       +
       

     

       361
       361
       +
         moveOrConvertImage = ''

     

       362
       362
       +
           ${if format == "raw" then ''

     

       363
       363
       +
             mv $diskImage $out/${filename}

     

       364
       364
       +
           '' else ''

     

       365
       365
       +
             ${pkgs.qemu}/bin/qemu-img convert -f raw -O ${format} ${compress} $diskImage $out/${filename}

     

       366
       366
       +
           ''}

     

       367
       367
       +
           diskImage=$out/${filename}

     

       368
       368
       +
         '';

     

       369
       369
       +
       

     

       370
       370
       +
         buildImage = pkgs.vmTools.runInLinuxVM (

     

       371
       371
       +
           pkgs.runCommand name {

     

       372
       372
       +
             preVM = prepareImage;

     

       329
       373
        
             buildInputs = with pkgs; [ util-linux e2fsprogs dosfstools ];

     

       330
       330
       -
             postVM = ''

     

       331
       331
       -
               ${if format == "raw" then ''

     

       332
       332
       -
                 mv $diskImage $out/${filename}

     

       333
       333
       -
               '' else ''

     

       334
       334
       -
                 ${pkgs.qemu}/bin/qemu-img convert -f raw -O ${format} ${compress} $diskImage $out/${filename}

     

       335
       335
       -
               ''}

     

       336
       336
       -
               diskImage=$out/${filename}

     

       337
       337
       -
               ${postVM}

     

       338
       338
       -
             '';

     

       374
       374
       +
             postVM = moveOrConvertImage + postVM;

     

       339
       375
        
             memSize = 1024;

     

       340
       340
       -
           }

     

       341
       341
       -
           ''

     

       376
       376
       +
           } ''

     

       342
       377
        
             export PATH=${binPath}:$PATH

     

       343
       378
        
       

     

       344
       379
        
             rootDisk=${if partitionTableType != "none" then "/dev/vda${rootPartition}" else "/dev/vda"}

     
···

       368
       403
        
               cp ${configFile} /mnt/etc/nixos/configuration.nix

     

       369
       404
        
             ''}

     

       370
       405
        
       

     

       371
       371
       -
             # Set up core system link, GRUB, etc.

     

       372
       372
       -
             NIXOS_INSTALL_BOOTLOADER=1 nixos-enter --root $mountPoint -- /nix/var/nix/profiles/system/bin/switch-to-configuration boot

     

       406
       406
       +
             ${lib.optionalString installBootLoader ''

     

       407
       407
       +
               # Set up core system link, GRUB, etc.

     

       408
       408
       +
               NIXOS_INSTALL_BOOTLOADER=1 nixos-enter --root $mountPoint -- /nix/var/nix/profiles/system/bin/switch-to-configuration boot

     

       373
       409
        
       

     

       374
       374
       -
             # The above scripts will generate a random machine-id and we don't want to bake a single ID into all our images

     

       375
       375
       -
             rm -f $mountPoint/etc/machine-id

     

       410
       410
       +
               # The above scripts will generate a random machine-id and we don't want to bake a single ID into all our images

     

       411
       411
       +
               rm -f $mountPoint/etc/machine-id

     

       412
       412
       +
             ''}

     

       376
       413
        
       

     

       377
       414
        
             # Set the ownerships of the contents. The modes are set in preVM.

     

       378
       415
        
             # No globbing on targets, so no need to set -f

     
···

       398
       435
        
               tune2fs -T now -c 0 -i 0 $rootDisk

     

       399
       436
        
             ''}

     

       400
       437
        
           ''

     

       401
       401
       -
       )

     

       438
       438
       +
         );

     

       439
       439
       +
       in

     

       440
       440
       +
         if onlyNixStore then

     

       441
       441
       +
           pkgs.runCommand name {}

     

       442
       442
       +
             (prepareImage + moveOrConvertImage + postVM)

     

       443
       443
       +
         else buildImage

+19

nixos/lib/testing-python.nix

···

       209
       209
        
           let

     

       210
       210
        
             nodes = qemu_pkg:

     

       211
       211
        
               let

     

       212
       212
       +
                 testScript' =

     

       213
       213
       +
                   # Call the test script with the computed nodes.

     

       214
       214
       +
                   if lib.isFunction testScript

     

       215
       215
       +
                   then testScript { nodes = nodes qemu_pkg; }

     

       216
       216
       +
                   else testScript;

     

       217
       217
       +
       

     

       212
       218
        
                 build-vms = import ./build-vms.nix {

     

       213
       219
        
                   inherit system lib pkgs minimal specialArgs;

     

       214
       220
        
                   extraConfigurations = extraConfigurations ++ [(

     

       215
       221
        
                     {

     

       216
       222
        
                       virtualisation.qemu.package = qemu_pkg;

     

       223
       223
       +
       

     

       224
       224
       +
                       # Make sure all derivations referenced by the test

     

       225
       225
       +
                       # script are available on the nodes. When the store is

     

       226
       226
       +
                       # accessed through 9p, this isn't important, since

     

       227
       227
       +
                       # everything in the store is available to the guest,

     

       228
       228
       +
                       # but when building a root image it is, as all paths

     

       229
       229
       +
                       # that should be available to the guest has to be

     

       230
       230
       +
                       # copied to the image.

     

       231
       231
       +
                       virtualisation.additionalPaths =

     

       232
       232
       +
                         lib.optional

     

       233
       233
       +
                           (builtins.hasContext testScript')

     

       234
       234
       +
                           (pkgs.writeStringReferencesToFile testScript');

     

       235
       235
       +
       

     

       217
       236
        
                       # Ensure we do not use aliases. Ideally this is only set

     

       218
       237
        
                       # when the test framework is used by Nixpkgs NixOS tests.

     

       219
       238
        
                       nixpkgs.config.allowAliases = false;

+70 -10

nixos/modules/virtualisation/qemu-vm.nix

···

       122
       122
        
                 TMPDIR=$(mktemp -d nix-vm.XXXXXXXXXX --tmpdir)

     

       123
       123
        
             fi

     

       124
       124
        
       

     

       125
       125
       +
             ${lib.optionalString cfg.useNixStoreImage

     

       126
       126
       +
             ''

     

       127
       127
       +
               # Create a writable copy/snapshot of the store image.

     

       128
       128
       +
               ${qemu}/bin/qemu-img create -f qcow2 -F qcow2 -b ${storeImage}/nixos.qcow2 "$TMPDIR"/store.img

     

       129
       129
       +
             ''}

     

       130
       130
       +
       

     

       125
       131
        
             # Create a directory for exchanging data with the VM.

     

       126
       132
        
             mkdir -p "$TMPDIR/xchg"

     

       127
       133
        
       

     
···

       171
       177
        
           '';

     

       172
       178
        
       

     

       173
       179
        
       

     

       174
       174
       -
         regInfo = pkgs.closureInfo { rootPaths = config.virtualisation.pathsInNixDB; };

     

       180
       180
       +
         regInfo = pkgs.closureInfo { rootPaths = config.virtualisation.additionalPaths; };

     

       175
       181
        
       

     

       176
       182
        
       

     

       177
       183
        
         # Generate a hard disk image containing a /boot partition and GRUB

     
···

       262
       268
        
                 umount /boot

     

       263
       269
        
               '' # */

     

       264
       270
        
           );

     

       271
       271
       +
       

     

       272
       272
       +
         storeImage = import ../../lib/make-disk-image.nix {

     

       273
       273
       +
           inherit pkgs config lib;

     

       274
       274
       +
           additionalPaths = [ regInfo ];

     

       275
       275
       +
           format = "qcow2";

     

       276
       276
       +
           onlyNixStore = true;

     

       277
       277
       +
           partitionTableType = "none";

     

       278
       278
       +
           installBootLoader = false;

     

       279
       279
       +
           diskSize = "auto";

     

       280
       280
       +
           additionalSpace = "0M";

     

       281
       281
       +
           copyChannel = false;

     

       282
       282
       +
         };

     

       265
       283
        
       

     

       266
       284
        
       in

     

       267
       285
        
       

     

       268
       286
        
       {

     

       269
       287
        
         imports = [

     

       270
       288
        
           ../profiles/qemu-guest.nix

     

       289
       289
       +
           (mkRenamedOptionModule [ "virtualisation" "pathsInNixDB" ] [ "virtualisation" "additionalPaths" ])

     

       271
       290
        
         ];

     

       272
       291
        
       

     

       273
       292
        
         options = {

     
···

       399
       418
        
                 '';

     

       400
       419
        
             };

     

       401
       420
        
       

     

       402
       402
       -
           virtualisation.pathsInNixDB =

     

       421
       421
       +
           virtualisation.additionalPaths =

     

       403
       422
        
             mkOption {

     

       404
       423
        
               type = types.listOf types.path;

     

       405
       424
        
               default = [];

     

       406
       425
        
               description =

     

       407
       426
        
                 ''

     

       408
       408
       -
                   The list of paths whose closure is registered in the Nix

     

       409
       409
       -
                   database in the VM.  All other paths in the host Nix store

     

       427
       427
       +
                   A list of paths whose closure should be made available to

     

       428
       428
       +
                   the VM.

     

       429
       429
       +
       

     

       430
       430
       +
                   When 9p is used, the closure is registered in the Nix

     

       431
       431
       +
                   database in the VM. All other paths in the host Nix store

     

       410
       432
        
                   appear in the guest Nix store as well, but are considered

     

       411
       433
        
                   garbage (because they are not registered in the Nix

     

       412
       412
       -
                   database in the guest).

     

       434
       434
       +
                   database of the guest).

     

       435
       435
       +
       

     

       436
       436
       +
                   When <option>virtualisation.useNixStoreImage</option> is

     

       437
       437
       +
                   set, the closure is copied to the Nix store image.

     

       413
       438
        
                 '';

     

       414
       439
        
             };

     

       415
       440
        
       

     
···

       608
       633
        
               };

     

       609
       634
        
           };

     

       610
       635
        
       

     

       636
       636
       +
           virtualisation.useNixStoreImage =

     

       637
       637
       +
             mkOption {

     

       638
       638
       +
               type = types.bool;

     

       639
       639
       +
               default = false;

     

       640
       640
       +
               description = ''

     

       641
       641
       +
                 Build and use a disk image for the Nix store, instead of

     

       642
       642
       +
                 accessing the host's one through 9p.

     

       643
       643
       +
       

     

       644
       644
       +
                 For applications which do a lot of reads from the store,

     

       645
       645
       +
                 this can drastically improve performance, but at the cost of

     

       646
       646
       +
                 disk space and image build time.

     

       647
       647
       +
               '';

     

       648
       648
       +
             };

     

       649
       649
       +
       

     

       611
       650
        
           virtualisation.useBootLoader =

     

       612
       651
        
             mkOption {

     

       613
       652
        
               type = types.bool;

     
···

       740
       779
        
             '';

     

       741
       780
        
       

     

       742
       781
        
           # After booting, register the closure of the paths in

     

       743
       743
       -
           # `virtualisation.pathsInNixDB' in the Nix database in the VM.  This

     

       782
       782
       +
           # `virtualisation.additionalPaths' in the Nix database in the VM.  This

     

       744
       783
        
           # allows Nix operations to work in the VM.  The path to the

     

       745
       784
        
           # registration file is passed through the kernel command line to

     

       746
       785
        
           # allow `system.build.toplevel' to be included.  (If we had a direct

     
···

       759
       798
        
       

     

       760
       799
        
           virtualisation.bootDevice = mkDefault (driveDeviceName 1);

     

       761
       800
        
       

     

       762
       762
       -
           virtualisation.pathsInNixDB = [ config.system.build.toplevel ];

     

       801
       801
       +
           virtualisation.additionalPaths = [ config.system.build.toplevel ];

     

       763
       802
        
       

     

       764
       803
        
           virtualisation.sharedDirectories = {

     

       765
       765
       -
             nix-store = { source = "/nix/store"; target = "/nix/store"; };

     

       766
       766
       -
             xchg      = { source = ''"$TMPDIR"/xchg''; target = "/tmp/xchg"; };

     

       767
       767
       -
             shared    = { source = ''"''${SHARED_DIR:-$TMPDIR/xchg}"''; target = "/tmp/shared"; };

     

       804
       804
       +
             nix-store = mkIf (!cfg.useNixStoreImage) {

     

       805
       805
       +
               source = builtins.storeDir;

     

       806
       806
       +
               target = "/nix/store";

     

       807
       807
       +
             };

     

       808
       808
       +
             xchg = {

     

       809
       809
       +
               source = ''"$TMPDIR"/xchg'';

     

       810
       810
       +
               target = "/tmp/xchg";

     

       811
       811
       +
             };

     

       812
       812
       +
             shared = {

     

       813
       813
       +
               source = ''"''${SHARED_DIR:-$TMPDIR/xchg}"'';

     

       814
       814
       +
               target = "/tmp/shared";

     

       815
       815
       +
             };

     

       768
       816
        
           };

     

       769
       817
        
       

     

       770
       818
        
           virtualisation.qemu.networkingOptions =

     
···

       815
       863
        
               driveExtraOpts.cache = "writeback";

     

       816
       864
        
               driveExtraOpts.werror = "report";

     

       817
       865
        
             }]

     

       866
       866
       +
             (mkIf cfg.useNixStoreImage [{

     

       867
       867
       +
               name = "nix-store";

     

       868
       868
       +
               file = ''"$TMPDIR"/store.img'';

     

       869
       869
       +
               deviceExtraOpts.bootindex = if cfg.useBootLoader then "3" else "2";

     

       870
       870
       +
             }])

     

       818
       871
        
             (mkIf cfg.useBootLoader [

     

       819
       872
        
               # The order of this list determines the device names, see

     

       820
       873
        
               # note [Disk layout with `useBootLoader`].

     
···

       864
       917
        
                   # Sync with systemd's tmp.mount;

     

       865
       918
        
                   options = [ "mode=1777" "strictatime" "nosuid" "nodev" "size=${toString config.boot.tmpOnTmpfsSize}" ];

     

       866
       919
        
                 };

     

       920
       920
       +
       

     

       921
       921
       +
               "/nix/${if cfg.writableStore then ".ro-store" else "store"}" =

     

       922
       922
       +
                 mkIf cfg.useNixStoreImage

     

       923
       923
       +
                   { device = "${lookupDriveDeviceName "nix-store" cfg.qemu.drives}";

     

       924
       924
       +
                     neededForBoot = true;

     

       925
       925
       +
                     options = [ "ro" ];

     

       926
       926
       +
                   };

     

       867
       927
        
       

     

       868
       928
        
               "/nix/.rw-store" = mkIf (cfg.writableStore && cfg.writableStoreUseTmpfs)

     

       869
       929
        
                 { fsType = "tmpfs";

+1 -1

nixos/tests/containers-bridge.nix

···

       56
       56
        
               };

     

       57
       57
        
       

     

       58
       58
        
       

     

       59
       59
       -
             virtualisation.pathsInNixDB = [ pkgs.stdenv ];

     

       59
       59
       +
             virtualisation.additionalPaths = [ pkgs.stdenv ];

     

       60
       60
        
           };

     

       61
       61
        
       

     

       62
       62
        
         testScript = ''

+1 -1

nixos/tests/containers-extra_veth.nix

···

       45
       45
        
                   };

     

       46
       46
        
               };

     

       47
       47
        
       

     

       48
       48
       -
             virtualisation.pathsInNixDB = [ pkgs.stdenv ];

     

       48
       48
       +
             virtualisation.additionalPaths = [ pkgs.stdenv ];

     

       49
       49
        
           };

     

       50
       50
        
       

     

       51
       51
        
         testScript =

+1 -1

nixos/tests/containers-imperative.nix

···

       17
       17
        
             virtualisation.memorySize = 1024;

     

       18
       18
        
             # Make sure we always have all the required dependencies for creating a

     

       19
       19
        
             # container available within the VM, because we don't have network access.

     

       20
       20
       -
             virtualisation.pathsInNixDB = let

     

       20
       20
       +
             virtualisation.additionalPaths = let

     

       21
       21
        
               emptyContainer = import ../lib/eval-config.nix {

     

       22
       22
        
                 inherit (config.nixpkgs.localSystem) system;

     

       23
       23
        
                 modules = lib.singleton {

+1 -1

nixos/tests/containers-ip.nix

···

       27
       27
        
       

     

       28
       28
        
             containers.webserver4 = webserverFor "10.231.136.1" "10.231.136.2";

     

       29
       29
        
             containers.webserver6 = webserverFor "fc00::2" "fc00::1";

     

       30
       30
       -
             virtualisation.pathsInNixDB = [ pkgs.stdenv ];

     

       30
       30
       +
             virtualisation.additionalPaths = [ pkgs.stdenv ];

     

       31
       31
        
           };

     

       32
       32
        
       

     

       33
       33
        
         testScript = { nodes, ... }: ''

+1 -1

nixos/tests/containers-portforward.nix

···

       29
       29
        
                   };

     

       30
       30
        
               };

     

       31
       31
        
       

     

       32
       32
       -
             virtualisation.pathsInNixDB = [ pkgs.stdenv ];

     

       32
       32
       +
             virtualisation.additionalPaths = [ pkgs.stdenv ];

     

       33
       33
        
           };

     

       34
       34
        
       

     

       35
       35
        
         testScript =

+1 -1

nixos/tests/containers-tmpfs.nix

···

       26
       26
        
                 config = { };

     

       27
       27
        
               };

     

       28
       28
        
       

     

       29
       29
       -
             virtualisation.pathsInNixDB = [ pkgs.stdenv ];

     

       29
       29
       +
             virtualisation.additionalPaths = [ pkgs.stdenv ];

     

       30
       30
        
           };

     

       31
       31
        
       

     

       32
       32
        
         testScript = ''

+2

nixos/tests/discourse.nix

···

       28
       28
        
             { nodes, ... }:

     

       29
       29
        
             {

     

       30
       30
        
               virtualisation.memorySize = 2048;

     

       31
       31
       +
               virtualisation.cores = 4;

     

       32
       32
       +
               virtualisation.useNixStoreImage = true;

     

       31
       33
        
       

     

       32
       34
        
               imports = [ common/user-account.nix ];

     

       33
       35

+2

nixos/tests/gitlab.nix

···

       14
       14
        
             imports = [ common/user-account.nix ];

     

       15
       15
        
       

     

       16
       16
        
             virtualisation.memorySize = if pkgs.stdenv.is64bit then 4096 else 2047;

     

       17
       17
       +
             virtualisation.cores = 4;

     

       18
       18
       +
             virtualisation.useNixStoreImage = true;

     

       17
       19
        
             systemd.services.gitlab.serviceConfig.Restart = mkForce "no";

     

       18
       20
        
             systemd.services.gitlab-workhorse.serviceConfig.Restart = mkForce "no";

     

       19
       21
        
             systemd.services.gitaly.serviceConfig.Restart = mkForce "no";

+2 -2

pkgs/applications/misc/openlp/lib.nix

···

       5
       5
        
       # python deps

     

       6
       6
        
       , python, buildPythonPackage

     

       7
       7
        
       , alembic, beautifulsoup4, chardet, lxml, Mako, pyenchant

     

       8
       8
       -
       , pyqt5_with_qtwebkit, pyxdg, sip_4, sqlalchemy, sqlalchemy_migrate

     

       8
       8
       +
       , pyqt5_with_qtwebkit, pyxdg, sip_4, sqlalchemy, sqlalchemy-migrate

     

       9
       9
        
       }:

     

       10
       10
        
       

     

       11
       11
        
       buildPythonPackage rec {

     
···

       43
       43
        
           pyxdg

     

       44
       44
        
           sip_4

     

       45
       45
        
           sqlalchemy

     

       46
       46
       -
           sqlalchemy_migrate

     

       46
       46
       +
           sqlalchemy-migrate

     

       47
       47
        
         ];

     

       48
       48
        
       

     

       49
       49
        
         prePatch = ''

+1 -1

pkgs/applications/misc/pytrainer/default.nix

···

       36
       36
        
         };

     

       37
       37
        
       

     

       38
       38
        
         propagatedBuildInputs = with python.pkgs; [

     

       39
       39
       -
           sqlalchemy_migrate

     

       39
       39
       +
           sqlalchemy-migrate

     

       40
       40
        
           python-dateutil

     

       41
       41
        
           matplotlib

     

       42
       42
        
           lxml

+3 -3

pkgs/applications/networking/feedreaders/newsboat/default.nix

···

       3
       3
        
       

     

       4
       4
        
       rustPlatform.buildRustPackage rec {

     

       5
       5
        
         pname = "newsboat";

     

       6
       6
       -
         version = "2.24";

     

       6
       6
       +
         version = "2.25";

     

       7
       7
        
       

     

       8
       8
        
         src = fetchFromGitHub {

     

       9
       9
        
           owner = "newsboat";

     

       10
       10
        
           repo = "newsboat";

     

       11
       11
        
           rev = "r${version}";

     

       12
       12
       -
           sha256 = "0qb10w7pn9hiczjjpc0xanmc83p22ngcqcrkjwji5rl0sh8v9ii4";

     

       12
       12
       +
           sha256 = "sha256-TAnGDxTKYl4niouS6nYdJDaIngAPsPHr9Bw9L3cR2Xk=";

     

       13
       13
        
         };

     

       14
       14
        
       

     

       15
       15
       -
         cargoSha256 = "0vhr8qyw4f3lc208mgl1m3z42igkbwly6wcv7g7jrq3c6dcwyhjn";

     

       15
       15
       +
         cargoSha256 = "sha256-MxoyYBLbrCuLVa0p8JrYKSKu2oFPnXMwab42lhhAu48=";

     

       16
       16
        
       

     

       17
       17
        
         # TODO: Check if that's still needed

     

       18
       18
        
         postPatch = lib.optionalString stdenv.isDarwin ''

+3 -3

pkgs/applications/science/math/pcalc/default.nix

···

       19
       19
        
         meta = with lib; {

     

       20
       20
        
           homepage = "https://vapier.github.io/pcalc/";

     

       21
       21
        
           description = "Programmer's calculator";

     

       22
       22
       -
           license = licenses.gpl2;

     

       23
       23
       -
           maintainers = with lib.maintainers; [ ftrvxmtrx ];

     

       24
       24
       -
           platforms = lib.platforms.linux;

     

       22
       22
       +
           license = licenses.gpl2Plus;

     

       23
       23
       +
           maintainers = with maintainers; [ ftrvxmtrx ];

     

       24
       24
       +
           platforms = platforms.unix;

     

       25
       25
        
         };

     

       26
       26
        
       }

+2 -2

pkgs/applications/version-management/gitea/default.nix

···

       16
       16
        
       

     

       17
       17
        
       buildGoPackage rec {

     

       18
       18
        
         pname = "gitea";

     

       19
       19
       -
         version = "1.15.5";

     

       19
       19
       +
         version = "1.15.6";

     

       20
       20
        
       

     

       21
       21
        
         # not fetching directly from the git repo, because that lacks several vendor files for the web UI

     

       22
       22
        
         src = fetchurl {

     

       23
       23
        
           url = "https://github.com/go-gitea/gitea/releases/download/v${version}/gitea-src-${version}.tar.gz";

     

       24
       24
       -
           sha256 = "sha256-W+czWzo4keTLRPDLcTeYl3JSccwfq+P6k4ELADO9FVM=";

     

       24
       24
       +
           sha256 = "sha256-FMM/iQAxJcymv4jYBzaBXG0Uy8UxHh9gFWB5gzV9cn0=";

     

       25
       25
        
         };

     

       26
       26
        
       

     

       27
       27
        
         unpackPhase = ''

+82

pkgs/build-support/trivial-builders.nix

···

       465
       465
        
           '';

     

       466
       466
        
       

     

       467
       467
        
       

     

       468
       468
       +
         /*

     

       469
       469
       +
          * Extract a string's references to derivations and paths (its

     

       470
       470
       +
          * context) and write them to a text file, removing the input string

     

       471
       471
       +
          * itself from the dependency graph. This is useful when you want to

     

       472
       472
       +
          * make a derivation depend on the string's references, but not its

     

       473
       473
       +
          * contents (to avoid unnecessary rebuilds, for example).

     

       474
       474
       +
          *

     

       475
       475
       +
          * Note that this only works as intended on Nix >= 2.3.

     

       476
       476
       +
          */

     

       477
       477
       +
         writeStringReferencesToFile = string:

     

       478
       478
       +
           /*

     

       479
       479
       +
           * The basic operation this performs is to copy the string context

     

       480
       480
       +
           * from `string' to a second string and wrap that string in a

     

       481
       481
       +
           * derivation. However, that alone is not enough, since nothing in the

     

       482
       482
       +
           * string refers to the output paths of the derivations/paths in its

     

       483
       483
       +
           * context, meaning they'll be considered build-time dependencies and

     

       484
       484
       +
           * removed from the wrapper derivation's closure. Putting the

     

       485
       485
       +
           * necessary output paths in the new string is however not very

     

       486
       486
       +
           * straightforward - the attrset returned by `getContext' contains

     

       487
       487
       +
           * only references to derivations' .drv-paths, not their output

     

       488
       488
       +
           * paths. In order to "convert" them, we try to extract the

     

       489
       489
       +
           * corresponding paths from the original string using regex.

     

       490
       490
       +
           */

     

       491
       491
       +
           let

     

       492
       492
       +
             # Taken from https://github.com/NixOS/nix/blob/130284b8508dad3c70e8160b15f3d62042fc730a/src/libutil/hash.cc#L84

     

       493
       493
       +
             nixHashChars = "0123456789abcdfghijklmnpqrsvwxyz";

     

       494
       494
       +
             context = builtins.getContext string;

     

       495
       495
       +
             derivations = lib.filterAttrs (n: v: v ? outputs) context;

     

       496
       496
       +
             # Objects copied from outside of the store, such as paths and

     

       497
       497
       +
             # `builtins.fetch*`ed ones

     

       498
       498
       +
             sources = lib.attrNames (lib.filterAttrs (n: v: v ? path) context);

     

       499
       499
       +
             packages =

     

       500
       500
       +
               lib.mapAttrs'

     

       501
       501
       +
                 (name: value:

     

       502
       502
       +
                   {

     

       503
       503
       +
                     inherit value;

     

       504
       504
       +
                     name = lib.head (builtins.match "${builtins.storeDir}/[${nixHashChars}]+-(.*)\.drv" name);

     

       505
       505
       +
                   })

     

       506
       506
       +
                 derivations;

     

       507
       507
       +
             # The syntax of output paths differs between outputs named `out`

     

       508
       508
       +
             # and other, explicitly named ones. For explicitly named ones,

     

       509
       509
       +
             # the output name is suffixed as `-name`, but `out` outputs

     

       510
       510
       +
             # aren't suffixed at all, and thus aren't easily distinguished

     

       511
       511
       +
             # from named output paths. Therefore, we find all the named ones

     

       512
       512
       +
             # first so we can use them to remove false matches when looking

     

       513
       513
       +
             # for `out` outputs (see the definition of `outputPaths`).

     

       514
       514
       +
             namedOutputPaths =

     

       515
       515
       +
               lib.flatten

     

       516
       516
       +
                 (lib.mapAttrsToList

     

       517
       517
       +
                   (name: value:

     

       518
       518
       +
                     (map

     

       519
       519
       +
                       (output:

     

       520
       520
       +
                         lib.filter

     

       521
       521
       +
                           lib.isList

     

       522
       522
       +
                           (builtins.split "(${builtins.storeDir}/[${nixHashChars}]+-${name}-${output})" string))

     

       523
       523
       +
                       (lib.remove "out" value.outputs)))

     

       524
       524
       +
                   packages);

     

       525
       525
       +
             # Only `out` outputs

     

       526
       526
       +
             outputPaths =

     

       527
       527
       +
               lib.flatten

     

       528
       528
       +
                 (lib.mapAttrsToList

     

       529
       529
       +
                   (name: value:

     

       530
       530
       +
                     if lib.elem "out" value.outputs then

     

       531
       531
       +
                       lib.filter

     

       532
       532
       +
                         (x: lib.isList x &&

     

       533
       533
       +
                             # If the matched path is in `namedOutputPaths`,

     

       534
       534
       +
                             # it's a partial match of an output path where

     

       535
       535
       +
                             # the output name isn't `out`

     

       536
       536
       +
                             lib.all (o: !lib.hasPrefix (lib.head x) o) namedOutputPaths)

     

       537
       537
       +
                         (builtins.split "(${builtins.storeDir}/[${nixHashChars}]+-${name})" string)

     

       538
       538
       +
                     else

     

       539
       539
       +
                       [])

     

       540
       540
       +
                   packages);

     

       541
       541
       +
             allPaths = lib.concatStringsSep "\n" (lib.unique (sources ++ namedOutputPaths ++ outputPaths));

     

       542
       542
       +
             allPathsWithContext = builtins.appendContext allPaths context;

     

       543
       543
       +
           in

     

       544
       544
       +
             if builtins ? getContext then

     

       545
       545
       +
               writeText "string-references" allPathsWithContext

     

       546
       546
       +
             else

     

       547
       547
       +
               writeDirectReferencesToFile (writeText "string-file" string);

     

       548
       548
       +
       

     

       549
       549
       +
       

     

       468
       550
        
         /* Print an error message if the file with the specified name and

     

       469
       551
        
          * hash doesn't exist in the Nix store. This function should only

     

       470
       552
        
          * be used by non-redistributable software with an unfree license

+21 -5

pkgs/build-support/trivial-builders/test.nix

···

       38
       38
        
             DIRECT_REFS = invokeSamples ./test/invoke-writeDirectReferencesToFile.nix;

     

       39
       39
        
           };

     

       40
       40
        
         };

     

       41
       41
       -
         testScript = ''

     

       42
       42
       -
           machine.succeed("""

     

       43
       43
       -
             ${./test.sh} 2>/dev/console

     

       44
       44
       -
           """)

     

       45
       45
       -
         '';

     

       41
       41
       +
         testScript =

     

       42
       42
       +
           let

     

       43
       43
       +
             sample = import ./test/sample.nix { inherit pkgs; };

     

       44
       44
       +
             samplePaths = lib.unique (lib.attrValues sample);

     

       45
       45
       +
             sampleText = pkgs.writeText "sample-text" (lib.concatStringsSep "\n" samplePaths);

     

       46
       46
       +
             stringReferencesText =

     

       47
       47
       +
               pkgs.writeStringReferencesToFile

     

       48
       48
       +
                 ((lib.concatMapStringsSep "fillertext"

     

       49
       49
       +
                   (d: "${d}")

     

       50
       50
       +
                   (lib.attrValues sample)) + ''

     

       51
       51
       +
                     STORE=${builtins.storeDir};\nsystemctl start bar-foo.service

     

       52
       52
       +
                   '');

     

       53
       53
       +
           in ''

     

       54
       54
       +
             machine.succeed("""

     

       55
       55
       +
               ${./test.sh} 2>/dev/console

     

       56
       56
       +
             """)

     

       57
       57
       +
             machine.succeed("""

     

       58
       58
       +
               echo >&2 Testing string references...

     

       59
       59
       +
               diff -U3 <(sort ${stringReferencesText}) <(sort ${sampleText})

     

       60
       60
       +
             """)

     

       61
       61
       +
           '';

     

       46
       62
        
         meta = {

     

       47
       63
        
           license = lib.licenses.mit; # nixpkgs license

     

       48
       64
        
           maintainers = with lib.maintainers; [

+6

pkgs/build-support/trivial-builders/test/sample.nix

···

       2
       2
        
       let

     

       3
       3
        
         inherit (pkgs)

     

       4
       4
        
           figlet

     

       5
       5
       +
           zlib

     

       5
       6
        
           hello

     

       6
       7
        
           writeText

     

       7
       8
        
           ;

     
···

       9
       10
        
       {

     

       10
       11
        
         hello = hello;

     

       11
       12
        
         figlet = figlet;

     

       13
       13
       +
         zlib = zlib;

     

       14
       14
       +
         zlib-dev = zlib.dev;

     

       12
       15
        
         norefs = writeText "hi" "hello";

     

       16
       16
       +
         norefsDup = writeText "hi" "hello";

     

       13
       17
        
         helloRef = writeText "hi" "hello ${hello}";

     

       18
       18
       +
         helloRefDup = writeText "hi" "hello ${hello}";

     

       19
       19
       +
         path = ./invoke-writeReferencesToFile.nix;

     

       14
       20
        
         helloFigletRef = writeText "hi" "hello ${hello} ${figlet}";

     

       15
       21
        
         inherit (pkgs)

     

       16
       22
        
           emptyFile

+2 -2

pkgs/development/compilers/gcc/8/default.nix

···

       54
       54
        
       with builtins;

     

       55
       55
        
       

     

       56
       56
        
       let majorVersion = "8";

     

       57
       57
       -
           version = "${majorVersion}.4.0";

     

       57
       57
       +
           version = "${majorVersion}.5.0";

     

       58
       58
        
       

     

       59
       59
        
           inherit (stdenv) buildPlatform hostPlatform targetPlatform;

     

       60
       60
        
       

     
···

       90
       90
        
       

     

       91
       91
        
         src = fetchurl {

     

       92
       92
        
           url = "mirror://gcc/releases/gcc-${version}/gcc-${version}.tar.xz";

     

       93
       93
       -
           sha256 = "1m1d3gfix56w4aq8myazzfffkl8bqcrx4jhhapnjf7qfs596w2p3";

     

       93
       93
       +
           sha256 = "0l7d4m9jx124xsk6xardchgy2k5j5l2b15q322k31f0va4d8826k";

     

       94
       94
        
         };

     

       95
       95
        
       

     

       96
       96
        
         inherit patches;

+19

pkgs/development/ocaml-modules/dune-site/default.nix

···

       1
       1
       +
       { lib, buildDunePackage, dune_2, dune-private-libs }:

     

       2
       2
       +
       

     

       3
       3
       +
       buildDunePackage rec {

     

       4
       4
       +
         pname = "dune-site";

     

       5
       5
       +
         inherit (dune_2) src version patches;

     

       6
       6
       +
       

     

       7
       7
       +
         useDune2 = true;

     

       8
       8
       +
       

     

       9
       9
       +
         dontAddPrefix = true;

     

       10
       10
       +
       

     

       11
       11
       +
         propagatedBuildInputs = [ dune-private-libs ];

     

       12
       12
       +
       

     

       13
       13
       +
         meta = with lib; {

     

       14
       14
       +
           description = "A library for embedding location information inside executable and libraries";

     

       15
       15
       +
           inherit (dune_2.meta) homepage;

     

       16
       16
       +
           maintainers = with lib.maintainers; [ superherointj ];

     

       17
       17
       +
           license = licenses.mit;

     

       18
       18
       +
         };

     

       19
       19
       +
       }

+2 -2

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

···

       13
       13
        
       

     

       14
       14
        
       buildPythonPackage rec {

     

       15
       15
        
         pname = "aionotion";

     

       16
       16
       -
         version = "3.0.2";

     

       16
       16
       +
         version = "2021.10.0";

     

       17
       17
        
         format = "pyproject";

     

       18
       18
        
         disabled = pythonOlder "3.6";

     

       19
       19
        
       

     
···

       21
       21
        
           owner = "bachya";

     

       22
       22
        
           repo = pname;

     

       23
       23
        
           rev = version;

     

       24
       24
       -
           sha256 = "1328g2245h9gcrnzrbcxaxw78723d0skznrrj8k77fbijxdc4kwv";

     

       24
       24
       +
           sha256 = "sha256-5bu2XveDi2e6lGdI/T+0apqXzcnqdztVtaHEpp+Vkzs=";

     

       25
       25
        
         };

     

       26
       26
        
       

     

       27
       27
        
         nativeBuildInputs = [ poetry-core ];

+2 -2

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

···

       17
       17
        
       

     

       18
       18
        
       buildPythonPackage rec {

     

       19
       19
        
         pname = "aioridwell";

     

       20
       20
       -
         version = "0.2.0";

     

       20
       20
       +
         version = "2021.10.0";

     

       21
       21
        
         format = "pyproject";

     

       22
       22
        
       

     

       23
       23
        
         disabled = pythonOlder "3.8";

     
···

       26
       26
        
           owner = "bachya";

     

       27
       27
        
           repo = pname;

     

       28
       28
        
           rev = version;

     

       29
       29
       -
           sha256 = "0kzxh1igncql1rwh12n42qahlc94z0fsd344d1vgni50jg7i34v7";

     

       29
       29
       +
           sha256 = "sha256-h89gfdZvk7H22xAczaPMscTYZu0YeFxvFfL6/Oz2cJw=";

     

       30
       30
        
         };

     

       31
       31
        
       

     

       32
       32
        
         nativeBuildInputs = [

+2 -2

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

···

       12
       12
        
       

     

       13
       13
        
       buildPythonPackage rec {

     

       14
       14
        
         pname = "aiowatttime";

     

       15
       15
       -
         version = "0.1.1";

     

       15
       15
       +
         version = "2021.10.0";

     

       16
       16
        
         format = "pyproject";

     

       17
       17
        
       

     

       18
       18
        
         disabled = pythonOlder "3.8";

     
···

       21
       21
        
           owner = "bachya";

     

       22
       22
        
           repo = pname;

     

       23
       23
        
           rev = version;

     

       24
       24
       -
           sha256 = "1614p5ca7x9ipz7dgwhiz83dfwn6hyliawa8pr2j9y2kn8cg2sdm";

     

       24
       24
       +
           sha256 = "sha256-cWXhQMgRYBzOVgUQWONIwWFB5n/f0lqkSjUb9IoPwtI=";

     

       25
       25
        
         };

     

       26
       26
        
       

     

       27
       27
        
         nativeBuildInputs = [

+2 -2

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

···

       1
       1
        
       { lib, buildPythonPackage, fetchPypi, pythonOlder, setuptools

     

       2
       2
        
       , twiggy, requests, offtrac, bugzilla, taskw, python-dateutil, pytz, keyring, six

     

       3
       3
       -
       , jinja2, pycurl, dogpile_cache, lockfile, click, pyxdg, future, jira }:

     

       3
       3
       +
       , jinja2, pycurl, dogpile-cache, lockfile, click, pyxdg, future, jira }:

     

       4
       4
        
       

     

       5
       5
        
       buildPythonPackage rec {

     

       6
       6
        
         pname = "bugwarrior";

     
···

       15
       15
        
         propagatedBuildInputs = [

     

       16
       16
        
           setuptools

     

       17
       17
        
           twiggy requests offtrac bugzilla taskw python-dateutil pytz keyring six

     

       18
       18
       -
           jinja2 pycurl dogpile_cache lockfile click pyxdg future jira

     

       18
       18
       +
           jinja2 pycurl dogpile-cache lockfile click pyxdg future jira

     

       19
       19
        
         ];

     

       20
       20
        
       

     

       21
       21
        
         # for the moment oauth2client <4.0.0 and megaplan>=1.4 are missing for running the test suite.

+2 -2

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

···

       1
       1
        
       { stdenv, lib, buildPythonPackage, fetchPypi, makeWrapper, isPy3k

     

       2
       2
        
       , python, twisted, jinja2, zope_interface, sqlalchemy

     

       3
       3
       -
       , sqlalchemy_migrate, python-dateutil, txaio, autobahn, pyjwt, pyyaml, unidiff, treq

     

       3
       3
       +
       , sqlalchemy-migrate, python-dateutil, txaio, autobahn, pyjwt, pyyaml, unidiff, treq

     

       4
       4
        
       , txrequests, pypugjs, boto3, moto, mock, lz4, setuptoolsTrial

     

       5
       5
        
       , isort, pylint, flake8, buildbot-worker, buildbot-pkg, buildbot-plugins

     

       6
       6
        
       , parameterized, git, openssh, glibcLocales, ldap3, nixosTests

     
···

       44
       44
        
             jinja2

     

       45
       45
        
             zope_interface

     

       46
       46
        
             sqlalchemy

     

       47
       47
       -
             sqlalchemy_migrate

     

       47
       47
       +
             sqlalchemy-migrate

     

       48
       48
        
             python-dateutil

     

       49
       49
        
             txaio

     

       50
       50
        
             autobahn

+2 -2

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

···

       5
       5
        
       , setuptools-scm

     

       6
       6
        
       , libdeltachat

     

       7
       7
        
       , cffi

     

       8
       8
       -
       , IMAPClient

     

       8
       8
       +
       , imapclient

     

       9
       9
        
       , pluggy

     

       10
       10
        
       , requests

     

       11
       11
        
       , setuptools

     
···

       31
       31
        
       

     

       32
       32
        
         propagatedBuildInputs = [

     

       33
       33
        
           cffi

     

       34
       34
       -
           IMAPClient

     

       34
       34
       +
           imapclient

     

       35
       35
        
           pluggy

     

       36
       36
        
           requests

     

       37
       37
        
           setuptools

+9 -11

pkgs/development/python-modules/dogpile.cache/default.nix pkgs/development/python-modules/dogpile-cache/default.nix

···

       2
       2
        
       , buildPythonPackage

     

       3
       3
        
       , fetchPypi

     

       4
       4
        
       , pythonOlder

     

       5
       5
       -
       , pytest

     

       6
       6
       -
       , pytest-cov

     

       5
       5
       +
       , pytestCheckHook

     

       7
       6
        
       , mock

     

       8
       7
        
       , Mako

     

       9
       8
        
       , decorator

     
···

       11
       10
        
       }:

     

       12
       11
        
       

     

       13
       12
        
       buildPythonPackage rec {

     

       14
       14
       -
         pname = "dogpile.cache";

     

       13
       13
       +
         pname = "dogpile-cache";

     

       15
       14
        
         version = "1.1.4";

     

       16
       15
        
         disabled = pythonOlder "3.6";

     

       17
       16
        
       

     

       18
       17
        
         src = fetchPypi {

     

       19
       19
       -
           inherit pname version;

     

       18
       18
       +
           pname = "dogpile.cache";

     

       19
       19
       +
           inherit version;

     

       20
       20
        
           sha256 = "ea09bebf24bb7c028caf98963785fe9ad0bd397305849a3303bc5380d468d813";

     

       21
       21
        
         };

     

       22
       22
        
       

     

       23
       23
       -
         # Disable concurrency tests that often fail,

     

       24
       24
       -
         # probably some kind of timing issue.

     

       25
       25
       -
         postPatch = ''

     

       23
       23
       +
         preCheck = ''

     

       24
       24
       +
           # Disable concurrency tests that often fail,

     

       25
       25
       +
           # probably some kind of timing issue.

     

       26
       26
        
           rm tests/test_lock.py

     

       27
       27
        
           # Failing tests. https://bitbucket.org/zzzeek/dogpile.cache/issues/116

     

       28
       28
        
           rm tests/cache/test_memcached_backend.py

     

       29
       29
        
         '';

     

       30
       30
        
       

     

       31
       31
        
         dontUseSetuptoolsCheck = true;

     

       32
       32
       -
         checkPhase = ''

     

       33
       33
       -
           pytest

     

       34
       34
       -
         '';

     

       35
       32
        
       

     

       36
       36
       -
         checkInputs = [ pytest pytest-cov mock Mako ];

     

       33
       33
       +
         checkInputs = [ pytestCheckHook mock Mako ];

     

       37
       34
        
       

     

       38
       35
        
         propagatedBuildInputs = [ decorator stevedore ];

     

       39
       36
        
       

     
···

       41
       38
        
           description = "A caching front-end based on the Dogpile lock";

     

       42
       39
        
           homepage = "https://bitbucket.org/zzzeek/dogpile.cache";

     

       43
       40
        
           license = licenses.bsd3;

     

       41
       41
       +
           maintainers = with maintainers; [ ];

     

       44
       42
        
         };

     

       45
       43
        
       }

+6 -2

pkgs/development/python-modules/dogpile.core/default.nix pkgs/development/python-modules/dogpile-core/default.nix

···

       1
       1
        
       { lib, buildPythonPackage, fetchPypi }:

     

       2
       2
        
       

     

       3
       3
        
       buildPythonPackage rec {

     

       4
       4
       -
         pname = "dogpile.core";

     

       4
       4
       +
         pname = "dogpile-core";

     

       5
       5
        
         version = "0.4.1";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchPypi {

     

       8
       8
       -
           inherit pname version;

     

       8
       8
       +
           pname = "dogpile.core";

     

       9
       9
       +
           inherit version;

     

       9
       10
        
           sha256 = "0xpdvg4kr1isfkrh1rfsh7za4q5a5s6l2kf9wpvndbwf3aqjyrdy";

     

       10
       11
        
         };

     

       11
       12
        
       

     

       12
       13
        
         doCheck = false;

     

       13
       14
        
       

     

       15
       15
       +
         pythonImportsCheck = [ "dogpile.core" ];

     

       16
       16
       +
       

     

       14
       17
        
         meta = with lib; {

     

       15
       18
        
           description = "A 'dogpile' lock, typically used as a component of a larger caching solution";

     

       16
       19
        
           homepage = "https://bitbucket.org/zzzeek/dogpile.core";

     

       17
       20
        
           license = licenses.bsd3;

     

       21
       21
       +
           maintainers = with maintainers; [ ];

     

       18
       22
        
         };

     

       19
       23
        
       }

+1 -1

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

···

       7
       7
        
       }:

     

       8
       8
        
       

     

       9
       9
        
       buildPythonPackage rec {

     

       10
       10
       -
         pname = "IMAPClient";

     

       10
       10
       +
         pname = "imapclient";

     

       11
       11
        
         version = "2.2.0";

     

       12
       12
        
       

     

       13
       13
        
         src = fetchFromGitHub {

+2 -2

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

···

       7
       7
        
       , dnspython

     

       8
       8
        
       , html2text

     

       9
       9
        
       , mail-parser

     

       10
       10
       -
       , IMAPClient

     

       10
       10
       +
       , imapclient

     

       11
       11
        
       }:

     

       12
       12
        
       

     

       13
       13
        
       buildPythonPackage rec {

     
···

       25
       25
        
           dnspython

     

       26
       26
        
           html2text

     

       27
       27
        
           mail-parser

     

       28
       28
       -
           IMAPClient

     

       28
       28
       +
           imapclient

     

       29
       29
        
         ];

     

       30
       30
        
       

     

       31
       31
        
         pythonImportsCheck = [ "mailsuite" ];

+2 -2

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

···

       4
       4
        
       , fetchPypi

     

       5
       5
        
       , appdirs

     

       6
       6
        
       , cryptography

     

       7
       7
       -
       , dogpile_cache

     

       7
       7
       +
       , dogpile-cache

     

       8
       8
        
       , jmespath

     

       9
       9
        
       , jsonpatch

     

       10
       10
        
       , keystoneauth1

     
···

       29
       29
        
         propagatedBuildInputs = [

     

       30
       30
        
           appdirs

     

       31
       31
        
           cryptography

     

       32
       32
       -
           dogpile_cache

     

       32
       32
       +
           dogpile-cache

     

       33
       33
        
           jmespath

     

       34
       34
        
           jsonpatch

     

       35
       35
        
           keystoneauth1

+2 -2

pkgs/development/python-modules/oslo-db/default.nix

···

       8
       8
        
       , oslotest

     

       9
       9
        
       , pbr

     

       10
       10
        
       , sqlalchemy

     

       11
       11
       -
       , sqlalchemy_migrate

     

       11
       11
       +
       , sqlalchemy-migrate

     

       12
       12
        
       , stestr

     

       13
       13
        
       , testresources

     

       14
       14
        
       , testscenarios

     
···

       32
       32
        
           oslo-context

     

       33
       33
        
           oslo-utils

     

       34
       34
        
           sqlalchemy

     

       35
       35
       -
           sqlalchemy_migrate

     

       35
       35
       +
           sqlalchemy-migrate

     

       36
       36
        
           testresources

     

       37
       37
        
           testscenarios

     

       38
       38
        
         ];

+2 -2

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

···

       14
       14
        
       , publicsuffix2

     

       15
       15
        
       , xmltodict

     

       16
       16
        
       , geoip2

     

       17
       17
       -
       , IMAPClient

     

       17
       17
       +
       , imapclient

     

       18
       18
        
       , dateparser

     

       19
       19
        
       , elasticsearch-dsl

     

       20
       20
        
       , kafka-python

     
···

       49
       49
        
           publicsuffix2

     

       50
       50
        
           xmltodict

     

       51
       51
        
           geoip2

     

       52
       52
       -
           IMAPClient

     

       52
       52
       +
           imapclient

     

       53
       53
        
           dateparser

     

       54
       54
        
           elasticsearch-dsl

     

       55
       55
        
           kafka-python

+2 -2

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

···

       12
       12
        
       

     

       13
       13
        
       buildPythonPackage rec {

     

       14
       14
        
         pname = "phonopy";

     

       15
       15
       -
         version = "2.11.0";

     

       15
       15
       +
         version = "2.12.0";

     

       16
       16
        
       

     

       17
       17
        
         src = fetchPypi {

     

       18
       18
        
           inherit pname version;

     

       19
       19
       -
           sha256 = "2ab47d3eb53a5265f3567974d29760b510b3312217358b76efc27ade9bd1a9f0";

     

       19
       19
       +
           sha256 = "ff65065f418ccbff9fbc1186b9a65581e83b42789aa4a656f45badfff9bd3f61";

     

       20
       20
        
         };

     

       21
       21
        
       

     

       22
       22
        
         propagatedBuildInputs = [

+2 -2

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

···

       4
       4
        
       , pbr

     

       5
       5
        
       , appdirs

     

       6
       6
        
       , cliff

     

       7
       7
       -
       , dogpile_cache

     

       7
       7
       +
       , dogpile-cache

     

       8
       8
        
       , jsonschema

     

       9
       9
        
       , keystoneauth1

     

       10
       10
        
       , openstacksdk

     
···

       31
       31
        
           pbr

     

       32
       32
        
           appdirs

     

       33
       33
        
           cliff

     

       34
       34
       -
           dogpile_cache

     

       34
       34
       +
           dogpile-cache

     

       35
       35
        
           jsonschema

     

       36
       36
        
           keystoneauth1

     

       37
       37
        
           openstacksdk

+2 -2

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

···

       7
       7
        
       , beautifulsoup4

     

       8
       8
        
       , requests

     

       9
       9
        
       , click

     

       10
       10
       -
       , dogpile_cache

     

       10
       10
       +
       , dogpile-cache

     

       11
       11
        
       , stevedore

     

       12
       12
        
       , chardet

     

       13
       13
        
       , pysrt

     
···

       34
       34
        
       

     

       35
       35
        
         propagatedBuildInputs = [

     

       36
       36
        
           guessit babelfish enzyme beautifulsoup4 requests

     

       37
       37
       -
           click dogpile_cache stevedore chardet pysrt six

     

       37
       37
       +
           click dogpile-cache stevedore chardet pysrt six

     

       38
       38
        
           appdirs rarfile pytz

     

       39
       39
        
         ];

     

       40
       40

+8 -8

pkgs/development/tools/electron/default.nix

···

       115
       115
        
           headers = "1fvqkw08pync38ixi5cq4f8a108k2ajxpm1w2f8sn2hjph9kpbsd";

     

       116
       116
        
         };

     

       117
       117
        
       

     

       118
       118
       -
         electron_13 = mkElectron "13.6.0" {

     

       119
       119
       -
           armv7l-linux = "03141d99268b1e71b64fd663c678591a02544c99475967d511041ab2c5de262c";

     

       120
       120
       -
           aarch64-linux = "309014cce9216e3b0a0015a7a31c33e39c63af0b7781e50d3e630fb1d7d3a4ee";

     

       121
       121
       -
           x86_64-linux = "b7f88baa69ea6c06ca16e215b01ad673cd922d3a0c9239868ddd0072af4e035e";

     

       122
       122
       -
           i686-linux = "b588e4fe82e6c37fe838a3cf592a2a4cf6166f26dad97dd7597818d7714ddc94";

     

       123
       123
       -
           x86_64-darwin = "250228bc5a186601d831f86faf394fba732436ddec86c1ef70e4d3d7ff9342c7";

     

       124
       124
       -
           aarch64-darwin = "fd3886830fa291db38cc770176ddb3167f8fb90065fcb124394b3ca32965108d";

     

       125
       125
       -
           headers = "1rmx0gvcsvba24fsjv14vmmd52h1nzscgmf1g9i46kzc13y0hn4z";

     

       118
       118
       +
         electron_13 = mkElectron "13.6.1" {

     

       119
       119
       +
           armv7l-linux = "c8bba8da0baf5cde3eb4823c801c228abfa7943c69131b3701c74e2b342e1813";

     

       120
       120
       +
           aarch64-linux = "09a1ff29c33a23f19cc702e0147dee03cfe2acedcff6bfb63c7911184b871a1a";

     

       121
       121
       +
           x86_64-linux = "bfc09dd2d591ad614c8d598dad6e13b76c3baf4f48773e7819c493b524a0bb1a";

     

       122
       122
       +
           i686-linux = "1ea7c7d19759fa0ee0ddef68c09bcc1c57265436d3f5dab37dad3567f117f317";

     

       123
       123
       +
           x86_64-darwin = "ce45f17f875d72e791999eaf30a1af39b6e9143e57a653e7f06cfa0bee9b985d";

     

       124
       124
       +
           aarch64-darwin = "e2f82720acae3a03d7d4b3e7dcc7697b84d5bb69a63d087a7420ace2412e7a28";

     

       125
       125
       +
           headers = "1bd87c74863w0sjs8gfxl62kjjscc56dmmw85vhwz01s4niksr02";

     

       126
       126
        
         };

     

       127
       127
        
       

     

       128
       128
        
         electron_14 = mkElectron "14.2.0" {

+3 -3

pkgs/development/tools/misc/terraform-ls/default.nix

···

       2
       2
        
       

     

       3
       3
        
       buildGoModule rec {

     

       4
       4
        
         pname = "terraform-ls";

     

       5
       5
       -
         version = "0.22.0";

     

       5
       5
       +
         version = "0.23.0";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "hashicorp";

     

       9
       9
        
           repo = pname;

     

       10
       10
        
           rev = "v${version}";

     

       11
       11
       -
           sha256 = "sha256-sfAn9FkOs9/yA7ciRD9gWbx5VwZveqPMYBQhSBkzYlo=";

     

       11
       11
       +
           sha256 = "sha256-hntHEBc1/KSg12x+gv32aNiA2cJ7PWBeftNhI8u+rlw=";

     

       12
       12
        
         };

     

       13
       13
       -
         vendorSha256 = "sha256-egv2+4esvfYccwmyHm23bec/QN6dGWvJVLG19959LPY=";

     

       13
       13
       +
         vendorSha256 = "sha256-usPIhXWdp/pSAFH0LepG1/Uolfr/1SExinrAjMuB6zg=";

     

       14
       14
        
       

     

       15
       15
        
         ldflags = [ "-s" "-w" "-X main.version=v${version}" "-X main.prerelease=" ];

     

       16
       16

+2 -2

pkgs/misc/screensavers/xscreensaver/default.nix

···

       9
       9
        
       }:

     

       10
       10
        
       

     

       11
       11
        
       stdenv.mkDerivation rec {

     

       12
       12
       -
         version = "6.01";

     

       12
       12
       +
         version = "6.02";

     

       13
       13
        
         pname = "xscreensaver";

     

       14
       14
        
       

     

       15
       15
        
         src = fetchurl {

     

       16
       16
        
           url = "https://www.jwz.org/${pname}/${pname}-${version}.tar.gz";

     

       17
       17
       -
           sha256 = "sha256-CFSEZl2R9gtKHe2s2UvPm3Sw+wlrztyJ/xwkUWjlRzs=";

     

       17
       17
       +
           sha256 = "sha256-Xm1ssJAzrVYs/m1Gv5MS5EUfeUa+2KRnGqk0TfkZMYQ=";

     

       18
       18
        
         };

     

       19
       19
        
       

     

       20
       20
        
         nativeBuildInputs = [

+2 -2

pkgs/tools/misc/lnav/default.nix

···

       3
       3
        
       

     

       4
       4
        
       stdenv.mkDerivation rec {

     

       5
       5
        
         pname = "lnav";

     

       6
       6
       -
         version = "0.10.0";

     

       6
       6
       +
         version = "0.10.1";

     

       7
       7
        
       

     

       8
       8
        
         src = fetchFromGitHub {

     

       9
       9
        
           owner = "tstack";

     

       10
       10
        
           repo = "lnav";

     

       11
       11
        
           rev = "v${version}";

     

       12
       12
       -
           sha256 = "sha256-hAFyMypGC065aRgX2L4LdyFGpZ/LnX5SjA2iQv5Iuas=";

     

       12
       12
       +
           sha256 = "sha256-1b4mVKIUotMSK/ADHnpiM42G98JF0abL8sXXGFyS3sw=";

     

       13
       13
        
         };

     

       14
       14
        
       

     

       15
       15
        
         patches = [ ./0001-Forcefully-disable-docs-build.patch ];

+3 -3

pkgs/tools/misc/tz/default.nix

···

       2
       2
        
       

     

       3
       3
        
       buildGoModule rec {

     

       4
       4
        
         pname = "tz";

     

       5
       5
       -
         version = "0.5";

     

       5
       5
       +
         version = "0.6.1";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "oz";

     

       9
       9
        
           repo = "tz";

     

       10
       10
        
           rev = "v${version}";

     

       11
       11
       -
           sha256 = "sha256-OwjhV3n1B1yQTNYm4VOW500t0524g85YYiOAAu9yPeo=";

     

       11
       11
       +
           sha256 = "sha256-D0rakLZ+swrDwBMcr+EJPgaYsQTWob50QteW1PoIdNk=";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
       -
         vendorSha256 = "sha256-Soa87I7oMa34LjYKxNAz9Limi0kQ6JUtb/zI4G7yZnw=";

     

       14
       14
       +
         vendorSha256 = "sha256-gMHPWf/kFb55GyyMciLWRzvrQXUGDQ72RNkIhkMVe54=";

     

       15
       15
        
       

     

       16
       16
        
         meta = with lib; {

     

       17
       17
        
           description = "A time zone helper";

+2 -2

pkgs/tools/misc/yubikey-manager-qt/default.nix

···

       14
       14
        
       

     

       15
       15
        
       mkDerivation rec {

     

       16
       16
        
         pname = "yubikey-manager-qt";

     

       17
       17
       -
         version = "1.2.3";

     

       17
       17
       +
         version = "1.2.4";

     

       18
       18
        
       

     

       19
       19
        
         src = fetchurl {

     

       20
       20
        
           url = "https://developers.yubico.com/${pname}/Releases/${pname}-${version}.tar.gz";

     

       21
       21
       -
           sha256 = "sha256-54HvuJXjm846sBxwNHLmaBXvO24bbBDyK8YvY4I6LjY=";

     

       21
       21
       +
           sha256 = "sha256-PxHc7IeRsO+CPrNTofGypLLW8fSHDkcBqr75NwdlUyc=";

     

       22
       22
        
         };

     

       23
       23
        
       

     

       24
       24
        
         nativeBuildInputs = [

+1 -1

pkgs/tools/package-management/nox/default.nix

···

       15
       15
        
         buildInputs = [ python3Packages.pbr git ];

     

       16
       16
        
       

     

       17
       17
        
         propagatedBuildInputs = with python3Packages; [

     

       18
       18
       -
             dogpile_cache

     

       18
       18
       +
             dogpile-cache

     

       19
       19
        
             click

     

       20
       20
        
             requests

     

       21
       21
        
             characteristic

+2

pkgs/top-level/ocaml-packages.nix

···

       321
       321
        
             inherit (pkgs) opam git mercurial coreutils gnutar bzip2;

     

       322
       322
        
           };

     

       323
       323
        
       

     

       324
       324
       +
           dune-site = callPackage ../development/ocaml-modules/dune-site { };

     

       325
       325
       +
       

     

       324
       326
        
           duration =  callPackage ../development/ocaml-modules/duration { };

     

       325
       327
        
       

     

       326
       328
        
           earley = callPackage ../development/ocaml-modules/earley { };

+18 -15

pkgs/top-level/python-aliases.nix

···

       33
       33
        
         ### Deprecated aliases - for backward compatibility

     

       34
       34
        
       

     

       35
       35
        
       mapAliases ({

     

       36
       36
       -
         blockdiagcontrib-cisco = throw "blockdiagcontrib-cisco is not compatible with blockdiag 2.0.0 and has been removed."; # Added 2020-11-29

     

       36
       36
       +
         blockdiagcontrib-cisco = throw "blockdiagcontrib-cisco is not compatible with blockdiag 2.0.0 and has been removed."; # added 2020-11-29

     

       37
       37
        
         bt_proximity = bt-proximity; # added 2021-07-02

     

       38
       38
       -
         bugseverywhere = throw "bugseverywhere has been removed: Abandoned by upstream."; # Added 2019-11-27

     

       38
       38
       +
         bugseverywhere = throw "bugseverywhere has been removed: Abandoned by upstream."; # added 2019-11-27

     

       39
       39
        
         class-registry = phx-class-registry; # added 2021-10-05

     

       40
       40
        
         ConfigArgParse = configargparse; # added 2021-03-18

     

       41
       41
        
         dateutil = python-dateutil; # added 2021-07-03

     

       42
       42
        
         detox = throw "detox is no longer maintained, and was broken since may 2019"; # added 2020-07-04

     

       43
       43
       -
         dftfit = throw "it's dependency lammps-cython no longer builds";

     

       43
       43
       +
         dftfit = throw "it's dependency lammps-cython no longer builds"; # added 2021-07-04

     

       44
       44
        
         diff_cover = diff-cover; # added 2021-07-02

     

       45
       45
        
         discogs_client = discogs-client; # added 2021-07-02

     

       46
       46
       -
         djangorestframework-jwt = drf-jwt;

     

       47
       47
       -
         dns = dnspython; # Alias for compatibility, 2017-12-10

     

       48
       48
       -
         faulthandler = throw "faulthandler is built into ${python.executable}";

     

       46
       46
       +
         djangorestframework-jwt = drf-jwt; # added 2021-07-20

     

       47
       47
       +
         dns = dnspython; # added 2017-12-10

     

       48
       48
       +
         dogpile_cache = dogpile-cache; # added 2021-10-28

     

       49
       49
       +
         faulthandler = throw "faulthandler is built into ${python.executable}"; # added 2021-07-12

     

       49
       50
        
         gitdb2 = throw "gitdb2 has been deprecated, use gitdb instead."; # added 2020-03-14

     

       50
       51
        
         glances = throw "glances has moved to pkgs.glances"; # added 2020-20-28

     

       51
       52
        
         google_api_python_client = google-api-python-client; # added 2021-03-19

     

       52
       53
        
         googleapis_common_protos = googleapis-common-protos; # added 2021-03-19

     

       53
       54
        
         grpc_google_iam_v1 = grpc-google-iam-v1; # added 2021-08-21

     

       54
       55
        
         HAP-python = hap-python; # added 2021-06-01

     

       56
       56
       +
         IMAPClient = imapclient; # added 2021-10-28

     

       55
       57
        
         jupyter_client = jupyter-client; # added 2021-10-15

     

       56
       58
        
         lammps-cython = throw "no longer builds and is unmaintained";

     

       57
       59
        
         MechanicalSoup = mechanicalsoup; # added 2021-06-01

     

       58
       60
        
         pam = python-pam; # added 2020-09-07.

     

       59
       59
       -
         PasteDeploy = pastedeploy;

     

       60
       60
       -
         powerlineMemSegment = powerline-mem-segment;

     

       61
       61
       +
         PasteDeploy = pastedeploy; # added 2021-10-07

     

       62
       62
       +
         powerlineMemSegment = powerline-mem-segment; # added 2021-10-08

     

       61
       63
        
         privacyidea = throw "renamed to pkgs.privacyidea"; # added 2021-06-20

     

       62
       64
        
         prometheus_client = prometheus-client; # added 2021-06-10

     

       63
       63
       -
         prompt_toolkit = prompt-toolkit;

     

       65
       65
       +
         prompt_toolkit = prompt-toolkit; # added 2021-07-22

     

       64
       66
        
         pylibgen = throw "pylibgen is unmaintained upstreamed, and removed from nixpkgs"; # added 2020-06-20

     

       65
       67
        
         pymssql = throw "pymssql has been abandoned upstream."; # added 2020-05-04

     

       66
       68
        
         pysmart-smartx = pysmart; # added 2021-10-22

     
···

       77
       79
        
         requests_toolbelt = requests-toolbelt; # added 2017-09-26

     

       78
       80
        
         rotate-backups = throw "pythonPackages.rotate-backups was removed in favor of the top-level rotate-backups"; # added 2021-07-01

     

       79
       81
        
         scikitlearn = scikit-learn; # added 2021-07-21

     

       80
       80
       -
         selectors34 = throw "selectors34 has been removed: functionality provided by Python itself; archived by upstream."; # Added 2021-06-10

     

       82
       82
       +
         selectors34 = throw "selectors34 has been removed: functionality provided by Python itself; archived by upstream."; # added 2021-06-10

     

       81
       83
        
         setuptools_scm = setuptools-scm; # added 2021-06-03

     

       82
       84
        
         smart_open = smart-open; # added 2021-03-14

     

       83
       85
        
         smmap2 = throw "smmap2 has been deprecated, use smmap instead."; # added 2020-03-14

     

       84
       84
       -
         sphinxcontrib_plantuml = sphinxcontrib-plantuml;

     

       85
       85
       -
         topydo = throw "python3Packages.topydo was moved to topydo"; # 2017-09-22

     

       86
       86
       -
         tvnamer = throw "python3Packages.tvnamer was moved to tvnamer"; # 2021-07-05

     

       87
       87
       -
         WazeRouteCalculator = wazeroutecalculator; # 2021-09-29

     

       88
       88
       -
         websocket_client = websocket-client;

     

       86
       86
       +
         sphinxcontrib_plantuml = sphinxcontrib-plantuml; # added 2021-08-02

     

       87
       87
       +
         sqlalchemy_migrate = sqlalchemy-migrate; # added 2021-10-28

     

       88
       88
       +
         topydo = throw "python3Packages.topydo was moved to topydo"; # added 2017-09-22

     

       89
       89
       +
         tvnamer = throw "python3Packages.tvnamer was moved to tvnamer"; # added 2021-07-05

     

       90
       90
       +
         WazeRouteCalculator = wazeroutecalculator; # added 2021-09-29

     

       91
       91
       +
         websocket_client = websocket-client; # added 2021-06-15

     

       89
       92
        
         zc-buildout221 = zc-buildout; # added 2021-07-21

     

       90
       93
        
       })

+4 -4

pkgs/top-level/python-packages.nix

···

       2257
       2257
        
       

     

       2258
       2258
        
         dodgy = callPackage ../development/python-modules/dodgy { };

     

       2259
       2259
        
       

     

       2260
       2260
       -
         dogpile_cache = callPackage ../development/python-modules/dogpile.cache { };

     

       2260
       2260
       +
         dogpile-cache = callPackage ../development/python-modules/dogpile-cache { };

     

       2261
       2261
        
       

     

       2262
       2262
       -
         dogpile_core = callPackage ../development/python-modules/dogpile.core { };

     

       2262
       2262
       +
         dogpile-core = callPackage ../development/python-modules/dogpile-core { };

     

       2263
       2263
        
       

     

       2264
       2264
        
         dogtail = callPackage ../development/python-modules/dogtail { };

     

       2265
       2265
        
       

     
···

       3668
       3668
        
       

     

       3669
       3669
        
         imantics = callPackage ../development/python-modules/imantics { };

     

       3670
       3670
        
       

     

       3671
       3671
       -
         IMAPClient = callPackage ../development/python-modules/imapclient { };

     

       3671
       3671
       +
         imapclient = callPackage ../development/python-modules/imapclient { };

     

       3672
       3672
        
       

     

       3673
       3673
        
         imaplib2 = callPackage ../development/python-modules/imaplib2 { };

     

       3674
       3674
        
       

     
···

       8780
       8780
        
       

     

       8781
       8781
        
         sqlalchemy-jsonfield = callPackage ../development/python-modules/sqlalchemy-jsonfield { };

     

       8782
       8782
        
       

     

       8783
       8783
       -
         sqlalchemy_migrate = callPackage ../development/python-modules/sqlalchemy-migrate { };

     

       8783
       8783
       +
         sqlalchemy-migrate = callPackage ../development/python-modules/sqlalchemy-migrate { };

     

       8784
       8784
        
       

     

       8785
       8785
        
         sqlalchemy-utils = callPackage ../development/python-modules/sqlalchemy-utils { };

     

       8786
       8786