Merge master into haskell-updates

doc/builders/fetchers.chapter.md

···
 
 A number of fetcher functions wrap part of `fetchurl` and `fetchzip`. They are mainly convenience functions intended for commonly used destinations of source code in Nixpkgs. These wrapper fetchers are listed below.
 
+## `fetchFromGitea` {#fetchfromgitea}
+
+`fetchFromGitea` expects five arguments. `domain` is the gitea server name. `owner` is a string corresponding to the Gitea user or organization that controls this repository. `repo` corresponds to the name of the software repository. These are located at the top of every Gitea HTML page as `owner`/`repo`. `rev` corresponds to the Git commit hash or tag (e.g `v1.0`) that will be downloaded from Git. Finally, `sha256` corresponds to the hash of the extracted directory. Again, other hash algorithms are also available but `sha256` is currently preferred.
+
 ## `fetchFromGitHub` {#fetchfromgithub}
 
 `fetchFromGitHub` expects four arguments. `owner` is a string corresponding to the GitHub user or organization that controls this repository. `repo` corresponds to the name of the software repository. These are located at the top of every GitHub HTML page as `owner`/`repo`. `rev` corresponds to the Git commit hash or tag (e.g `v1.0`) that will be downloaded from Git. Finally, `sha256` corresponds to the hash of the extracted directory. Again, other hash algorithms are also available but `sha256` is currently preferred.

doc/languages-frameworks/texlive.section.md

···
 
 - For basic usage just pull `texlive.combined.scheme-basic` for an environment with basic LaTeX support.
 
-- It typically won't work to use separately installed packages together. Instead, you can build a custom set of packages like this:
+- It typically won't work to use separately installed packages together. Instead, you can build a custom set of packages like this. Most CTAN packages should be available:
 
   ```nix
   texlive.combine {

lib/default.nix

···
       bitNot boolToString mergeAttrs flip mapNullable inNixShell isFloat min max
       importJSON importTOML warn warnIf throwIfNot checkListOfEnum
       info showWarnings nixpkgsVersion version isInOldestRelease
-      mod compare splitByAndCompare functionArgs setFunctionArgs isFunction
+      mod compare splitByAndCompare
+      functionArgs setFunctionArgs isFunction toFunction
       toHexString toBaseDigits;
     inherit (self.fixedPoints) fix fix' converge extends composeExtensions
       composeManyExtensions makeExtensible makeExtensibleWithCustomName;
···
       commitIdFromGitRepo cleanSourceWith pathHasContext
       canCleanSource pathIsRegularFile pathIsGitRepo;
     inherit (self.modules) evalModules setDefaultModuleLocation
-      unifyModuleSyntax applyIfFunction mergeModules
+      unifyModuleSyntax applyModuleArgsIfFunction mergeModules
       mergeModules' mergeOptionDecls evalOptionValue mergeDefinitions
       pushDownProperties dischargeProperties filterOverrides
       sortProperties fixupOptionType mkIf mkAssert mkMerge mkOverride

lib/modules.nix

···
       # Like unifyModuleSyntax, but also imports paths and calls functions if necessary
       loadModule = args: fallbackFile: fallbackKey: m:
         if isFunction m || isAttrs m then
-          unifyModuleSyntax fallbackFile fallbackKey (applyIfFunction fallbackKey m args)
+          unifyModuleSyntax fallbackFile fallbackKey (applyModuleArgsIfFunction fallbackKey m args)
         else if isList m then
           let defs = [{ file = fallbackFile; value = m; }]; in
           throw "Module imports can't be nested lists. Perhaps you meant to remove one level of lists? Definitions: ${showDefs defs}"
-        else unifyModuleSyntax (toString m) (toString m) (applyIfFunction (toString m) (import m) args);
+        else unifyModuleSyntax (toString m) (toString m) (applyModuleArgsIfFunction (toString m) (import m) args);
 
       /*
       Collects all modules recursively into the form
···
         config = addFreeformType (addMeta (removeAttrs m ["_file" "key" "disabledModules" "require" "imports" "freeformType"]));
       };
 
-  applyIfFunction = key: f: args@{ config, options, lib, ... }: if isFunction f then
+  applyModuleArgsIfFunction = key: f: args@{ config, options, lib, ... }: if isFunction f then
     let
       # Module arguments are resolved in a strict manner when attribute set
       # deconstruction is used.  As the arguments are now defined with the

lib/trivial.nix

···
   isFunction = f: builtins.isFunction f ||
     (f ? __functor && isFunction (f.__functor f));
 
+  /*
+    Turns any non-callable values into constant functions.
+    Returns callable values as is.
+
+    Example:
+
+      nix-repl> lib.toFunction 1 2
+      1
+
+      nix-repl> lib.toFunction (x: x + 1) 2
+      3
+  */
+  toFunction =
+    # Any value
+    v:
+    if isFunction v
+    then v
+    else k: v;
+
   /* Convert the given positive integer to a string of its hexadecimal
      representation. For example:
 

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

···
       </listitem>
       <listitem>
         <para>
+          <literal>services.ipfs.extraFlags</literal> is now escaped
+          with <literal>utils.escapeSystemdExecArgs</literal>. If you
+          rely on systemd interpolating <literal>extraFlags</literal> in
+          the service <literal>ExecStart</literal>, this will no longer
+          work.
+        </para>
+      </listitem>
+      <listitem>
+        <para>
           The <literal>matrix-synapse</literal> service
           (<literal>services.matrix-synapse</literal>) has been
           converted to use the <literal>settings</literal> option

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

···
 
 - The `mailpile` email webclient (`services.mailpile`) has been removed due to its reliance on python2.
 
+- `services.ipfs.extraFlags` is now escaped with `utils.escapeSystemdExecArgs`. If you rely on systemd interpolating `extraFlags` in the service `ExecStart`, this will no longer work.
+
 - The `matrix-synapse` service (`services.matrix-synapse`) has been converted to use the `settings` option defined in RFC42.
   This means that options that are part of your `homeserver.yaml` configuration, and that were specified at the top-level of the
   module (`services.matrix-synapse`) now need to be moved into `services.matrix-synapse.settings`. And while not all options you

nixos/lib/testing-python.nix

···
 
   # Make a full-blown test
   makeTest =
-    { testScript
+    { machine ? null
+    , nodes ? {}
+    , testScript
     , enableOCR ? false
     , name ? "unnamed"
       # Skip linting (mainly intended for faster dev cycles)
     , skipLint ? false
     , passthru ? {}
+    , meta ? {}
     , # For meta.position
       pos ? # position used in error messages and for meta.position
-        (if t.meta.description or null != null
-          then builtins.unsafeGetAttrPos "description" t.meta
+        (if meta.description or null != null
+          then builtins.unsafeGetAttrPos "description" meta
           else builtins.unsafeGetAttrPos "testScript" t)
-    , ...
     } @ t:
     let
-      nodes = qemu_pkg:
+      mkNodes = qemu_pkg:
         let
           testScript' =
             # Call the test script with the computed nodes.
             if lib.isFunction testScript
-            then testScript { nodes = nodes qemu_pkg; }
+            then testScript { nodes = mkNodes qemu_pkg; }
             else testScript;
 
           build-vms = import ./build-vms.nix {
···
           };
         in
           build-vms.buildVirtualNetwork (
-              t.nodes or (if t ? machine then { machine = t.machine; } else { })
+              nodes // lib.optionalAttrs (machine != null) { inherit machine; }
           );
 
       driver = setupDriverForTest {
         inherit testScript enableOCR skipLint passthru;
         testName = name;
         qemu_pkg = pkgs.qemu_test;
-        nodes = nodes pkgs.qemu_test;
+        nodes = mkNodes pkgs.qemu_test;
       };
       driverInteractive = setupDriverForTest {
         inherit testScript enableOCR skipLint passthru;
         testName = name;
         qemu_pkg = pkgs.qemu;
-        nodes = nodes pkgs.qemu;
+        nodes = mkNodes pkgs.qemu;
         interactive = true;
       };
 
-      test =
-        let
-          passMeta = drv: drv // lib.optionalAttrs (t ? meta) {
-            meta = (drv.meta or { }) // t.meta;
-          };
-        in passMeta (runTests { inherit driver pos driverInteractive; });
+      test = lib.addMetaAttrs meta (runTests { inherit driver pos driverInteractive; });
 
     in
       test // {
-        inherit test driver driverInteractive nodes;
+        inherit test driver driverInteractive;
+        inherit (driver) nodes;
       };
 
   abortForFunction = functionName: abort ''The ${functionName} function was

nixos/modules/installer/tools/tools.nix

···
     '';
   };
 
-  config = lib.mkIf (!config.system.disableInstallerTools) {
+  config = lib.mkIf (config.nix.enable && !config.system.disableInstallerTools) {
 
     system.nixos-generate-config.configuration = mkDefault ''
       # Edit this configuration file to define what should be installed on

nixos/modules/module-list.nix

···
   ./services/networking/headscale.nix
   ./services/networking/hostapd.nix
   ./services/networking/htpdate.nix
+  ./services/networking/https-dns-proxy.nix
   ./services/networking/hylafax/default.nix
   ./services/networking/i2pd.nix
   ./services/networking/i2p.nix

nixos/modules/services/logging/graylog.nix

···
         description = "Graylog server daemon user";
       };
     };
-    users.groups = mkIf (cfg.user == "graylog") {};
+    users.groups = mkIf (cfg.user == "graylog") { graylog = {}; };
 
     systemd.tmpfiles.rules = [
       "d '${cfg.messageJournalDir}' - ${cfg.user} - - -"

nixos/modules/services/misc/nix-gc.nix

···
   ###### implementation
 
   config = {
+    assertions = [
+      {
+        assertion = cfg.automatic -> config.nix.enable;
+        message = ''nix.gc.automatic requires nix.enable'';
+      }
+    ];
 
-    systemd.services.nix-gc = {
+    systemd.services.nix-gc = lib.mkIf config.nix.enable {
       description = "Nix Garbage Collector";
       script = "exec ${config.nix.package.out}/bin/nix-collect-garbage ${cfg.options}";
       startAt = optional cfg.automatic cfg.dates;

nixos/modules/services/misc/nix-optimise.nix

···
   ###### implementation
 
   config = {
+    assertions = [
+      {
+        assertion = cfg.automatic -> config.nix.enable;
+        message = ''nix.optimise.automatic requires nix.enable'';
+      }
+    ];
 
-    systemd.services.nix-optimise =
+    systemd.services.nix-optimise = lib.mkIf config.nix.enable
       { description = "Nix Store Optimiser";
         # No point this if the nix daemon (and thus the nix store) is outside
         unitConfig.ConditionPathIsReadWrite = "/nix/var/nix/daemon-socket";

nixos/modules/services/network-filesystems/ipfs.nix

···
-{ config, lib, pkgs, options, ... }:
+{ config, lib, pkgs, options, utils, ... }:
 with lib;
 let
   cfg = config.services.ipfs;
   opt = options.services.ipfs;
 
-  ipfsFlags = toString ([
-    (optionalString cfg.autoMount "--mount")
-    (optionalString cfg.enableGC "--enable-gc")
-    (optionalString (cfg.serviceFdlimit != null) "--manage-fdlimit=false")
-    (optionalString (cfg.defaultMode == "offline") "--offline")
-    (optionalString (cfg.defaultMode == "norouting") "--routing=none")
-  ] ++ cfg.extraFlags);
+  ipfsFlags = utils.escapeSystemdExecArgs (
+    optional cfg.autoMount "--mount" ++
+    optional cfg.enableGC "--enable-gc" ++
+    optional (cfg.serviceFdlimit != null) "--manage-fdlimit=false" ++
+    optional (cfg.defaultMode == "offline") "--offline" ++
+    optional (cfg.defaultMode == "norouting") "--routing=none" ++
+    cfg.extraFlags
+  );
 
   profile =
     if cfg.localDiscovery

nixos/modules/services/networking/https-dns-proxy.nix

···
+{ config, lib, pkgs, ... }:
+
+let
+  inherit (lib)
+    concatStringsSep
+    mkEnableOption mkIf mkOption types;
+
+  cfg = config.services.https-dns-proxy;
+
+  providers = {
+    cloudflare = {
+      ips = [ "1.1.1.1" "1.0.0.1" ];
+      url = "https://cloudflare-dns.com/dns-query";
+    };
+    google = {
+      ips = [ "8.8.8.8" "8.8.4.4" ];
+      url = "https://dns.google/dns-query";
+    };
+    quad9 = {
+      ips = [ "9.9.9.9" "149.112.112.112" ];
+      url = "https://dns.quad9.net/dns-query";
+    };
+  };
+
+  defaultProvider = "quad9";
+
+  providerCfg =
+    let
+      isCustom = cfg.provider.kind == "custom";
+    in
+    lib.concatStringsSep " " [
+      "-b"
+      (concatStringsSep "," (if isCustom then cfg.provider.ips else providers."${cfg.provider.kind}".ips))
+      "-r"
+      (if isCustom then cfg.provider.url else providers."${cfg.provider.kind}".url)
+    ];
+
+in
+{
+  meta.maintainers = with lib.maintainers; [ peterhoeg ];
+
+  ###### interface
+
+  options.services.https-dns-proxy = {
+    enable = mkEnableOption "https-dns-proxy daemon";
+
+    address = mkOption {
+      description = "The address on which to listen";
+      type = types.str;
+      default = "127.0.0.1";
+    };
+
+    port = mkOption {
+      description = "The port on which to listen";
+      type = types.port;
+      default = 5053;
+    };
+
+    provider = {
+      kind = mkOption {
+        description = ''
+          The upstream provider to use or custom in case you do not trust any of
+          the predefined providers or just want to use your own.
+
+          The default is ${defaultProvider} and there are privacy and security trade-offs
+          when using any upstream provider. Please consider that before using any
+          of them.
+
+          If you pick a custom provider, you will need to provide the bootstrap
+          IP addresses as well as the resolver https URL.
+        '';
+        type = types.enum ((builtins.attrNames providers) ++ [ "custom" ]);
+        default = defaultProvider;
+      };
+
+      ips = mkOption {
+        description = "The custom provider IPs";
+        type = types.listOf types.str;
+      };
+
+      url = mkOption {
+        description = "The custom provider URL";
+        type = types.str;
+      };
+    };
+
+    preferIPv4 = mkOption {
+      description = ''
+        https_dns_proxy will by default use IPv6 and fail if it is not available.
+        To play it safe, we choose IPv4.
+      '';
+      type = types.bool;
+      default = true;
+    };
+
+    extraArgs = mkOption {
+      description = "Additional arguments to pass to the process.";
+      type = types.listOf types.str;
+      default = [ "-v" ];
+    };
+  };
+
+  ###### implementation
+
+  config = lib.mkIf cfg.enable {
+    systemd.services.https-dns-proxy = {
+      description = "DNS to DNS over HTTPS (DoH) proxy";
+      after = [ "network.target" ];
+      wantedBy = [ "multi-user.target" ];
+      serviceConfig = rec {
+        Type = "exec";
+        DynamicUser = true;
+        ExecStart = lib.concatStringsSep " " (
+          [
+            "${pkgs.https-dns-proxy}/bin/https_dns_proxy"
+            "-a ${toString cfg.address}"
+            "-p ${toString cfg.port}"
+            "-l -"
+            providerCfg
+          ]
+          ++ lib.optional cfg.preferIPv4 "-4"
+          ++ cfg.extraArgs
+        );
+        Restart = "on-failure";
+      };
+    };
+  };
+}

nixos/modules/services/system/earlyoom.nix

···
 
   inherit (lib)
     mkDefault mkEnableOption mkIf mkOption types
-    mkRemovedOptionModule
-    concatStringsSep optional;
+    mkRemovedOptionModule literalExpression
+    escapeShellArg concatStringsSep optional optionalString;
 
 in
 {
···
       type = types.ints.between 1 100;
       default = 10;
       description = ''
-        Minimum of availabe memory (in percent).
-        If the free memory falls below this threshold and the analog is true for
-        <option>services.earlyoom.freeSwapThreshold</option>
-        the killing begins.
+        Minimum available memory (in percent).
+
+        If the available memory falls below this threshold (and the analog is true for
+        <option>freeSwapThreshold</option>) the killing begins.
+        SIGTERM is sent first to the process that uses the most memory; then, if the available
+        memory falls below <option>freeMemKillThreshold</option> (and the analog is true for
+        <option>freeSwapKillThreshold</option>), SIGKILL is sent.
+
+        See <link xlink:href="https://github.com/rfjakob/earlyoom#command-line-options">README</link> for details.
+      '';
+    };
+
+    freeMemKillThreshold = mkOption {
+      type = types.nullOr (types.ints.between 1 100);
+      default = null;
+      description = ''
+        Minimum available memory (in percent) before sending SIGKILL.
+        If unset, this defaults to half of <option>freeMemThreshold</option>.
+
+        See the description of <xref linkend="opt-services.earlyoom.freeMemThreshold"/>.
       '';
     };
 
···
       type = types.ints.between 1 100;
       default = 10;
       description = ''
-        Minimum of availabe swap space (in percent).
-        If the available swap space falls below this threshold and the analog
-        is true for <option>services.earlyoom.freeMemThreshold</option>
-        the killing begins.
+        Minimum free swap space (in percent) before sending SIGTERM.
+
+        See the description of <xref linkend="opt-services.earlyoom.freeMemThreshold"/>.
       '';
     };
 
-    # TODO: remove or warn after 1.7 (https://github.com/rfjakob/earlyoom/commit/7ebc4554)
-    ignoreOOMScoreAdjust = mkOption {
-      type = types.bool;
-      default = false;
+    freeSwapKillThreshold = mkOption {
+      type = types.nullOr (types.ints.between 1 100);
+      default = null;
       description = ''
-        Ignore oom_score_adjust values of processes.
+        Minimum free swap space (in percent) before sending SIGKILL.
+        If unset, this defaults to half of <option>freeSwapThreshold</option>.
+
+        See the description of <xref linkend="opt-services.earlyoom.freeMemThreshold"/>.
       '';
     };
 
···
         local user to DoS your session by spamming notifications.
 
         To actually see the notifications in your GUI session, you need to have
-        <literal>systembus-notify</literal> running as your user which this
-        option handles.
+        <literal>systembus-notify</literal> running as your user, which this
+        option handles by enabling <option>services.systembus-notify</option>.
 
         See <link xlink:href="https://github.com/rfjakob/earlyoom#notifications">README</link> for details.
       '';
     };
+
+    killHook = mkOption {
+      type = types.nullOr types.path;
+      default = null;
+      example = literalExpression ''
+        pkgs.writeShellScript "earlyoom-kill-hook" '''
+          echo "Process $EARLYOOM_NAME ($EARLYOOM_PID) was killed" >> /path/to/log
+        '''
+      '';
+      description = ''
+        An absolute path to an executable to be run for each process killed.
+        Some environment variables are available, see
+        <link xlink:href="https://github.com/rfjakob/earlyoom#notifications">README</link> and
+        <link xlink:href="https://github.com/rfjakob/earlyoom/blob/master/MANPAGE.md#-n-pathtoscript">the man page</link>
+        for details.
+      '';
+    };
+
+    reportInterval = mkOption {
+      type = types.int;
+      default = 3600;
+      example = 0;
+      description = "Interval (in seconds) at which a memory report is printed (set to 0 to disable).";
+    };
+
+    extraArgs = mkOption {
+      type = types.listOf types.str;
+      default = [];
+      example = [ "-g" "--prefer '(^|/)(java|chromium)$'" ];
+      description = "Extra command-line arguments to be passed to earlyoom.";
+    };
   };
 
   imports = [
···
       This option is deprecated and ignored by earlyoom since 1.2.
     '')
     (mkRemovedOptionModule [ "services" "earlyoom" "notificationsCommand" ] ''
-      This option is deprecated and ignored by earlyoom since 1.6.
+      This option was removed in earlyoom 1.6, but was reimplemented in 1.7
+      and is available as the new option `services.earlyoom.killHook`.
+    '')
+    (mkRemovedOptionModule [ "services" "earlyoom" "ignoreOOMScoreAdjust" ] ''
+      This option is deprecated and ignored by earlyoom since 1.7.
     '')
   ];
 
···
         StandardError = "journal";
         ExecStart = concatStringsSep " " ([
           "${pkgs.earlyoom}/bin/earlyoom"
-          "-m ${toString cfg.freeMemThreshold}"
-          "-s ${toString cfg.freeSwapThreshold}"
+          ("-m ${toString cfg.freeMemThreshold}"
+            + optionalString (cfg.freeMemKillThreshold != null) ",${toString cfg.freeMemKillThreshold}")
+          ("-s ${toString cfg.freeSwapThreshold}"
+            + optionalString (cfg.freeSwapKillThreshold != null) ",${toString cfg.freeSwapKillThreshold}")
+          "-r ${toString cfg.reportInterval}"
         ]
-        ++ optional cfg.ignoreOOMScoreAdjust "-i"
         ++ optional cfg.enableDebugInfo "-d"
         ++ optional cfg.enableNotifications "-n"
+        ++ optional (cfg.killHook != null) "-N ${escapeShellArg cfg.killHook}"
+        ++ cfg.extraArgs
         );
       };
     };

nixos/modules/tasks/network-interfaces-scripted.nix

···
         createGreDevice = n: v: nameValuePair "${n}-netdev"
           (let
             deps = deviceDependency v.dev;
+            ttlarg = if lib.hasPrefix "ip6" v.type then "hoplimit" else "ttl";
           in
           { description = "GRE Tunnel Interface ${n}";
             wantedBy = [ "network-setup.service" (subsystemDevice n) ];
···
               ip link add name "${n}" type ${v.type} \
                 ${optionalString (v.remote != null) "remote \"${v.remote}\""} \
                 ${optionalString (v.local != null) "local \"${v.local}\""} \
+                ${optionalString (v.ttl != null) "${ttlarg} ${toString v.ttl}"} \
                 ${optionalString (v.dev != null) "dev \"${v.dev}\""}
               ip link set "${n}" up
             '';

nixos/modules/tasks/network-interfaces-systemd.nix

···
               Remote = gre.remote;
             }) // (optionalAttrs (gre.local != null) {
               Local = gre.local;
+            }) // (optionalAttrs (gre.ttl != null) {
+              TTL = gre.ttl;
             });
         };
         networks = mkIf (gre.dev != null) {

nixos/modules/tasks/network-interfaces.nix

···
             local = "10.0.0.22";
             dev = "enp4s0f0";
             type = "tap";
+            ttl = 255;
           };
           gre6Tunnel = {
             remote = "fd7a:5634::1";
             local = "fd7a:5634::2";
             dev = "enp4s0f0";
             type = "tun6";
+            ttl = 255;
           };
         }
       '';
···
             example = "enp4s0f0";
             description = ''
               The underlying network device on which the tunnel resides.
+            '';
+          };
+
+          ttl = mkOption {
+            type = types.nullOr types.int;
+            default = null;
+            example = 255;
+            description = ''
+              The time-to-live/hoplimit of the connection to the remote tunnel endpoint.
             '';
           };
 

nixos/modules/virtualisation/qemu-vm.nix

···
     # allow `system.build.toplevel' to be included.  (If we had a direct
     # reference to ${regInfo} here, then we would get a cyclic
     # dependency.)
-    boot.postBootCommands =
+    boot.postBootCommands = lib.mkIf config.nix.enable
       ''
         if [[ "$(cat /proc/cmdline)" =~ regInfo=([^ ]*) ]]; then
           ${config.nix.package.out}/bin/nix-store --load-db < ''${BASH_REMATCH[1]}

nixos/tests/all-tests.nix

···
   domination = handleTest ./domination.nix {};
   dovecot = handleTest ./dovecot.nix {};
   drbd = handleTest ./drbd.nix {};
+  earlyoom = handleTestOn ["x86_64-linux"] ./earlyoom.nix {};
   ec2-config = (handleTestOn ["x86_64-linux"] ./ec2.nix {}).boot-ec2-config or {};
   ec2-nixops = (handleTestOn ["x86_64-linux"] ./ec2.nix {}).boot-ec2-nixops or {};
   ecryptfs = handleTest ./ecryptfs.nix {};

nixos/tests/boot.nix

···
       } // extraConfig);
     in
       makeTest {
-        inherit iso;
         name = "boot-" + name;
         nodes = { };
         testScript =

nixos/tests/caddy.nix

···
   nodes = {
     webserver = { pkgs, lib, ... }: {
       services.caddy.enable = true;
-      services.caddy.config = ''
+      services.caddy.extraConfig = ''
         http://localhost {
           encode gzip
 
···
       '';
 
       specialisation.etag.configuration = {
-        services.caddy.config = lib.mkForce ''
+        services.caddy.extraConfig = lib.mkForce ''
           http://localhost {
             encode gzip
 
···
       };
 
       specialisation.config-reload.configuration = {
-        services.caddy.config = ''
+        services.caddy.extraConfig = ''
           http://localhost:8080 {
           }
         '';

nixos/tests/ceph-multi-node.nix

···
       sudo
       ceph
       xfsprogs
-      netcat-openbsd
+      libressl.nc
     ];
 
     boot.kernelModules = [ "xfs" ];

nixos/tests/chromium.nix

···
 with import ../lib/testing-python.nix { inherit system pkgs; };
 with pkgs.lib;
 
-mapAttrs (channel: chromiumPkg: makeTest rec {
-  name = "chromium-${channel}";
-  meta = {
-    maintainers = with maintainers; [ aszlig primeos ];
-    # https://github.com/NixOS/hydra/issues/591#issuecomment-435125621
-    inherit (chromiumPkg.meta) timeout;
-  };
-
-  enableOCR = true;
-
+let
   user = "alice";
-
-  machine.imports = [ ./common/user-account.nix ./common/x11.nix ];
-  machine.virtualisation.memorySize = 2047;
-  machine.test-support.displayManager.auto.user = user;
-  machine.environment = {
-    systemPackages = [ chromiumPkg ];
-    variables."XAUTHORITY" = "/home/alice/.Xauthority";
-  };
 
   startupHTML = pkgs.writeText "chromium-startup.html" ''
     <!DOCTYPE html>
···
     </body>
     </html>
   '';
+in
+
+mapAttrs (channel: chromiumPkg: makeTest {
+  name = "chromium-${channel}";
+  meta = {
+    maintainers = with maintainers; [ aszlig primeos ];
+    # https://github.com/NixOS/hydra/issues/591#issuecomment-435125621
+    inherit (chromiumPkg.meta) timeout;
+  };
+
+  enableOCR = true;
+
+  machine.imports = [ ./common/user-account.nix ./common/x11.nix ];
+  machine.virtualisation.memorySize = 2047;
+  machine.test-support.displayManager.auto.user = user;
+  machine.environment = {
+    systemPackages = [ chromiumPkg ];
+    variables."XAUTHORITY" = "/home/alice/.Xauthority";
+  };
 
   testScript = let
     xdo = name: text: let

nixos/tests/cri-o.nix

···
 # This test runs CRI-O and verifies via critest
 import ./make-test-python.nix ({ pkgs, ... }: {
   name = "cri-o";
-  maintainers = with pkgs.lib.maintainers; teams.podman.members;
+  meta.maintainers = with pkgs.lib.maintainers; teams.podman.members;
 
   nodes = {
     crio = {

nixos/tests/earlyoom.nix

···
+import ./make-test-python.nix ({ lib, ... }: {
+  name = "earlyoom";
+  meta = {
+    maintainers = with lib.maintainers; [ ncfavier ];
+  };
+
+  machine = {
+    services.earlyoom = {
+      enable = true;
+    };
+  };
+
+  testScript = ''
+    machine.wait_for_unit("earlyoom.service")
+  '';
+})

nixos/tests/gitolite-fcgiwrap.nix

···
         nodes = {
 
           server =
-            { ... }:
+            { config, ... }:
               {
                 networking.firewall.allowedTCPPorts = [ 80 ];
 

nixos/tests/jitsi-meet.nix

···
         forceSSL = true;
       };
 
-      security.acme.email = "[e-mail]";
       security.acme.acceptTerms = true;
-      security.acme.server = "https://example.com"; # self-signed only
+      security.acme.defaults.email = "[e-mail]";
+      security.acme.defaults.server = "https://example.com"; # self-signed only
     };
   };
 

nixos/tests/misc.nix

···
 # Miscellaneous small tests that don't warrant their own VM run.
 
-import ./make-test-python.nix ({ pkgs, ...} : rec {
+import ./make-test-python.nix ({ pkgs, ...} : let
+  foo = pkgs.writeText "foo" "Hello World";
+in {
   name = "misc";
   meta = with pkgs.lib.maintainers; {
     maintainers = [ eelco ];
   };
-
-  foo = pkgs.writeText "foo" "Hello World";
 
   machine =
     { lib, ... }:

nixos/tests/networking.nix

···
                   local = "192.168.2.1";
                   remote = "192.168.2.2";
                   dev = "eth2";
+                  ttl = 225;
                   type = "tap";
                 };
                 gre6Tunnel = {
                   local = "fd00:1234:5678:4::1";
                   remote = "fd00:1234:5678:4::2";
                   dev = "eth3";
+                  ttl = 255;
                   type = "tun6";
                 };
               };
···
                   local = "192.168.2.2";
                   remote = "192.168.2.1";
                   dev = "eth1";
+                  ttl = 225;
                   type = "tap";
                 };
                 gre6Tunnel = {
                   local = "fd00:1234:5678:4::2";
                   remote = "fd00:1234:5678:4::1";
                   dev = "eth3";
+                  ttl = 255;
                   type = "tun6";
                 };
               };
···
         ];
       testScript = { ... }:
         ''
+          import json
           start_all()
 
           with subtest("Wait for networking to be configured"):
···
               client1.wait_until_succeeds("ping -c 1 fc00::2")
 
               client2.wait_until_succeeds("ping -c 1 fc00::1")
+
+          with subtest("Test GRE tunnel TTL"):
+              links = json.loads(client1.succeed("ip -details -json link show greTunnel"))
+              assert links[0]['linkinfo']['info_data']['ttl'] == 225, "ttl not set for greTunnel"
+
+              links = json.loads(client2.succeed("ip -details -json link show gre6Tunnel"))
+              assert links[0]['linkinfo']['info_data']['ttl'] == 255, "ttl not set for gre6Tunnel"
         '';
     };
     vlan = let

nixos/tests/rstudio-server.nix

···
       };
     };
 
-    users.testuser = {
-      uid = 1000;
-      group = "testgroup";
-    };
-    groups.testgroup.gid = 1000;
-
     testScript = ''
       machine.wait_for_unit("rstudio-server.service")
       machine.succeed("curl -f -vvv -s http://127.0.0.1:8787")

nixos/tests/step-ca.nix

···
 
         caclient =
           { config, pkgs, ... }: {
-            security.acme.server = "https://caserver:8443/acme/acme/directory";
-            security.acme.email = "[e-mail]";
+            security.acme.defaults.server = "https://caserver:8443/acme/acme/directory";
+            security.acme.defaults.email = "[e-mail]";
             security.acme.acceptTerms = true;
 
             security.pki.certificateFiles = [ "${test-certificates}/root_ca.crt" ];

nixos/tests/tor.nix

···
 import ./make-test-python.nix ({ lib, ... }: with lib;
 
-rec {
+{
   name = "tor";
   meta.maintainers = with maintainers; [ joachifm ];
 
-  common =
-    { ... }:
-    { boot.kernelParams = [ "audit=0" "apparmor=0" "quiet" ];
-      networking.firewall.enable = false;
-      networking.useDHCP = false;
-    };
+  nodes.client = { pkgs, ... }: {
+    boot.kernelParams = [ "audit=0" "apparmor=0" "quiet" ];
+    networking.firewall.enable = false;
+    networking.useDHCP = false;
 
-  nodes.client =
-    { pkgs, ... }:
-    { imports = [ common ];
-      environment.systemPackages = with pkgs; [ netcat ];
-      services.tor.enable = true;
-      services.tor.client.enable = true;
-      services.tor.settings.ControlPort = 9051;
-    };
+    environment.systemPackages = with pkgs; [ netcat ];
+    services.tor.enable = true;
+    services.tor.client.enable = true;
+    services.tor.settings.ControlPort = 9051;
+  };
 
   testScript = ''
     client.wait_for_unit("tor.service")

nixos/tests/without-nix.nix

···
     maintainers = [ ericson2314 ];
   };
 
-  nixpkgs.overlays = [
-    (self: super: {
-      nix = throw "don't want to use this";
-    })
-  ];
-
   nodes.machine = { ... }: {
     nix.enable = false;
+    nixpkgs.overlays = [
+      (self: super: {
+        nix = throw "don't want to use pkgs.nix";
+        nixVersions = lib.mapAttrs (k: throw "don't want to use pkgs.nixVersions.${k}") super.nixVersions;
+        # aliases, some deprecated
+        nix_2_3 = throw "don't want to use pkgs.nix_2_3";
+        nix_2_4 = throw "don't want to use pkgs.nix_2_4";
+        nix_2_5 = throw "don't want to use pkgs.nix_2_5";
+        nix_2_6 = throw "don't want to use pkgs.nix_2_6";
+        nixFlakes = throw "don't want to use pkgs.nixFlakes";
+        nixStable = throw "don't want to use pkgs.nixStable";
+        nixUnstable = throw "don't want to use pkgs.nixUnstable";
+        nixStatic = throw "don't want to use pkgs.nixStatic";
+      })
+    ];
   };
 
   testScript = ''

pkgs/applications/audio/magnetophonDSP/faustCompressors/default.nix

···
 { lib, stdenv, fetchFromGitHub, faust2jaqt, faust2lv2 }:
 stdenv.mkDerivation rec {
-  name = "faustCompressors-v${version}";
+  pname = "faustCompressors";
   version = "1.2";
 
   src = fetchFromGitHub {

pkgs/applications/audio/mopidy/youtube.nix

···
 
 python3.pkgs.buildPythonApplication rec {
   pname = "mopidy-youtube";
-  version = "3.4";
-
-  disabled = python3.pythonOlder "3.7";
+  version = "3.5";
+  format = "setuptools";
 
   src = fetchFromGitHub {
     owner = "natumbri";
     repo = pname;
     rev = "v${version}";
-    sha256 = "0lm6nn926qkrwzvj64yracdixfrnv5zk243msjskrnlzkhgk01rk";
+    hash = "sha256-hlokysFFgZZYY7flghgRq6wVG824kpcLkXxk6nMhxn4=";
   };
 
   propagatedBuildInputs = with python3.pkgs; [
···
   ];
 
   disabledTestPaths = [
-    # Fails with an import error
+    # Disable tests which interact with Youtube
+    "tests/test_api.py"
     "tests/test_backend.py"
+    "tests/test_youtube.py"
   ];
 
   pythonImportsCheck = [

pkgs/applications/audio/sound-juicer/default.nix

···
 { lib
 , stdenv
 , fetchurl
+, fetchpatch
 , meson
 , ninja
 , pkg-config
···
     url = "mirror://gnome/sources/${pname}/${lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
     sha256 = "08d5d81rz9sj3m5paw8fwbgxmhlbr7bcjdzpmzj832qvg8smydxf";
   };
+
+  patches = [
+    # Fix build with meson 0.61
+    # data/meson.build:2:5: ERROR: Function does not take positional arguments.
+    (fetchpatch {
+      url = "https://gitlab.gnome.org/GNOME/sound-juicer/-/commit/9f97ca1faca396099f52264a9729aa355f8d122e.patch";
+      sha256 = "8JllVSQgI7KiBI5WP6QtXRiggYuD89NSJJp1hP4Dbao=";
+    })
+  ];
 
   nativeBuildInputs = [
     meson

pkgs/applications/editors/hexdino/default.nix

···
 { lib, fetchFromGitHub, rustPlatform, ncurses }:
 
-rustPlatform.buildRustPackage {
+rustPlatform.buildRustPackage rec {
   pname = "hexdino";
-  version = "0.1.0";
+  version = "0.1.1";
 
   src = fetchFromGitHub {
     owner = "Luz";
-    repo = "hexdino";
-    rev = "de5b5d7042129f57e0ab36416a06476126bce389";
-    sha256 = "11mz07735gxqfamjcjjmxya6swlvr1p77sgd377zjcmd6z54gwyf";
+    repo = pname;
+    rev = version;
+    sha256 = "1n8gizawx8h58hpyyqivp7vwy7yhn6scipl5rrbvkpnav8qpmk1r";
   };
 
-  cargoSha256 = "1hpndmpk1zlfvb4r95m13yvnsbjkwgw4pb9ala2d5yzfp38225nm";
+  cargoSha256 = "01869b1d7gbsprcxxj7h9z16pvnzb02j2hywh97gfq5x96gnmkz3";
 
   buildInputs = [ ncurses ];
 

pkgs/applications/emulators/fceux/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "fceux";
-  version = "2.6.3";
+  version = "2.6.4";
 
   src = fetchFromGitHub {
     owner = "TASEmulators";
     repo = pname;
     rev = "${pname}-${version}";
-    sha256 = "sha256-jNR9AB8s2S9ehYsompkV2GOLsaXIQzldeQ1WRCxdDG0=";
+    sha256 = "sha256-Q6r/iBlmi0z40+U6OLZCahS0io4IBBGZMP1mJH7szRM=";
   };
 
   nativeBuildInputs = [ cmake pkg-config wrapQtAppsHook ];

pkgs/applications/graphics/unigine-heaven/default.nix

···
+{ lib
+, stdenv
+, fetchurl
+, makeWrapper
+, libX11
+, libXext
+, libXrandr
+, freetype
+, fontconfig
+, libXrender
+, libXinerama
+, autoPatchelfHook
+, libglvnd
+, openal
+, imagemagick
+, makeDesktopItem
+}:
+let
+  version = "4.0";
+
+  arch =
+    if stdenv.hostPlatform.system == "x86_64-linux" then
+      "x64"
+    else if stdenv.hostPlatform.system == "i686-linux" then
+      "x86"
+    else
+      throw "Unsupported platform ${stdenv.hostPlatform.system}";
+
+  desktopItem = makeDesktopItem {
+    name = "Heaven";
+    exec = "heaven";
+    genericName = "A GPU Stress test tool from the UNIGINE";
+    icon = "Heaven";
+    desktopName = "Heaven Benchmark";
+  };
+in
+stdenv.mkDerivation
+{
+  pname = "unigine-heaven";
+  inherit version;
+
+  src = fetchurl {
+    url = "https://assets.unigine.com/d/Unigine_Heaven-${version}.run";
+    sha256 = "19rndwwxnb9k2nw9h004hyrmr419471s0fp25yzvvc6rkd521c0v";
+  };
+
+  installPhase =
+    ''
+      sh $src --target $name
+
+      mkdir -p $out/lib/unigine/heaven/bin
+      mkdir -p $out/bin
+      mkdir -p $out/share/applications/
+      mkdir -p $out/share/icons/hicolor
+
+      install -m 0755 $name/bin/browser_${arch} $out/lib/unigine/heaven/bin
+      install -m 0755 $name/bin/libApp{Stereo,Surround,Wall}_${arch}.so $out/lib/unigine/heaven/bin
+      install -m 0755 $name/bin/libGPUMonitor_${arch}.so $out/lib/unigine/heaven/bin
+      install -m 0755 $name/bin/libQt{Core,Gui,Network,WebKit,Xml}Unigine_${arch}.so.4 $out/lib/unigine/heaven/bin
+      install -m 0755 $name/bin/libUnigine_${arch}.so $out/lib/unigine/heaven/bin
+      install -m 0755 $name/bin/heaven_${arch} $out/lib/unigine/heaven/bin
+      install -m 0755 $name/heaven $out/bin/heaven
+
+      cp -R $name/data $name/documentation $out/lib/unigine/heaven
+
+      wrapProgram $out/bin/heaven --prefix LD_LIBRARY_PATH : ${libglvnd}/lib:$out/bin:${openal}/lib --run "cd $out/lib/unigine/heaven/"
+
+      convert $out/lib/unigine/heaven/data/launcher/icon.png -resize 128x128 $out/share/icons/Heaven.png
+      for RES in 16 24 32 48 64 128 256
+      do
+          mkdir -p $out/share/icons/hicolor/"$RES"x"$RES"/apps
+          convert $out/lib/unigine/heaven/data/launcher/icon.png -resize "$RES"x"$RES" $out/share/icons/hicolor/"$RES"x"$RES"/apps/Heaven.png
+      done
+
+      ln -s ${desktopItem}/share/applications/* $out/share/applications
+    '';
+
+  nativeBuildInputs =
+    [
+      autoPatchelfHook
+      makeWrapper
+      imagemagick
+    ];
+
+  buildInputs =
+    [
+      libX11
+      stdenv.cc.cc
+      libXext
+      libXrandr
+      freetype
+      fontconfig
+      libXrender
+      libXinerama
+    ];
+
+  dontUnpack = true;
+
+  meta =
+    {
+      description = "The Unigine Heaven GPU benchmarking tool";
+      homepage = "https://benchmark.unigine.com/heaven";
+      license = lib.licenses.unfree;
+      maintainers = [ lib.maintainers.BarinovMaxim ];
+      platforms = [ "x86_64-linux" "i686-linux" ];
+    };
+}

pkgs/applications/graphics/xournal/default.nix

···
 
 stdenv.mkDerivation rec {
   version = "0.4.8.2016";
-  name = "xournal-" + version;
+  pname = "xournal";
   src = fetchurl {
-    url = "mirror://sourceforge/xournal/${name}.tar.gz";
+    url = "mirror://sourceforge/xournal/xournal-${version}.tar.gz";
     sha256 = "09i88v3wacmx7f96dmq0l3afpyv95lh6jrx16xzm0jd1szdrhn5j";
   };
 
···
     + lib.optionalString (!isGdkQuartzBackend) " -lX11";
 
   desktopItem = makeDesktopItem {
-    name = name;
+    name = "xournal-${version}";
     exec = "xournal";
     icon = "xournal";
     desktopName = "Xournal";

pkgs/applications/misc/avrdudess/default.nix

···
 
 stdenv.mkDerivation {
   pname = "avrdudess";
-  version = "2.2.20140102";
+  version = "2.13";
 
   src = fetchurl {
-    url = "http://blog.zakkemble.co.uk/download/avrdudess_20140102.zip";
-    sha256 = "18llpvjsfhypzijrvfbzmcg3g141f307mzsrg11wcdxh9syxqak6";
+    url = "https://github.com/ZakKemble/AVRDUDESS/releases/download/v2.13/AVRDUDESS-2.13-portable.zip";
+    sha256 = "0fpvc19fb14ppqfb2yg821szmhyanxcp5chfldf8yh51f64zihv9";
   };
 
   nativeBuildInputs = [ unzip ];
···
 
   meta = with lib; {
     description = "GUI for AVRDUDE (AVR microcontroller programmer)";
-    homepage = "https://github.com/zkemble/AVRDUDESS";
+    homepage = "https://blog.zakkemble.net/avrdudess-a-gui-for-avrdude/";
+    changelog = "https://github.com/ZakKemble/AVRDUDESS/blob/v${version}/Changelog.txt";
     license = licenses.gpl3;
     platforms = platforms.linux;
     maintainers = [ maintainers.bjornfor ];

pkgs/applications/misc/gosmore/default.nix

···
 { lib, stdenv, fetchsvn, libxml2, gtk2, curl, pkg-config } :
 
-let
+stdenv.mkDerivation rec {
+  pname = "gosmore";
   version = "31801";
-in
-stdenv.mkDerivation {
-  name = "gosmore-r${version}";
   # the gosmore svn repository does not lock revision numbers of its externals
   # so we explicitly disable them to avoid breaking the hash
   # especially as the externals appear to be unused

pkgs/applications/misc/lighthouse/default.nix

···
 }:
 
 stdenv.mkDerivation rec {
-  name = "lighthouse-${date}";
-  date = "2016-07-20";
+  pname = "lighthouse";
+  version = "unstable-2016-07-20";
 
   src = fetchFromGitHub {
     owner = "emgram769";

pkgs/applications/misc/mucommander/default.nix

···
 
 let
   version = "0.9.3-3";
-  name = "mucommander-${version}";
 
   src = fetchFromGitHub {
     owner = "mucommander";
···
 
   # fake build to pre-download deps into fixed-output derivation
   deps = stdenv.mkDerivation {
-    name = "${name}-deps";
-    inherit src postPatch;
+    pname = "mucommander-deps";
+    inherit version src postPatch;
     nativeBuildInputs = [ gradle_6 perl ];
     buildPhase = ''
       export GRADLE_USER_HOME=$(mktemp -d)
···
   };
 
 in stdenv.mkDerivation {
-  inherit name src postPatch;
+  pname = "mucommander";
+  inherit version src postPatch;
   nativeBuildInputs = [ gradle_6 perl makeWrapper ];
 
   buildPhase = ''

pkgs/applications/misc/obsidian/default.nix

···
       desktopName = "Obsidian";
       comment = "Knowledge base";
       icon = "obsidian";
-      exec = "obsidian";
+      exec = "obsidian %u";
       categories = [ "Office" ];
+      mimeTypes = [ "x-scheme-handler/obsidian" ];
     };
 
     inherit pname version src;

pkgs/applications/misc/pdfdiff/default.nix

···
 { lib, python2Packages, fetchurl, xpdf }:
-let
-  py = python2Packages;
-in
-py.buildPythonApplication rec {
-  name = "pdfdiff-${version}";
+
+python2Packages.buildPythonApplication rec {
+  pname = "pdfdiff";
   version = "0.92";
 
   src = fetchurl {

pkgs/applications/misc/pdfpc/default.nix

···
 , webkitgtk, discount, json-glib }:
 
 stdenv.mkDerivation rec {
-  name = "${product}-${version}";
-  product = "pdfpc";
+  pname = "pdfpc";
   version = "4.5.0";
 
   src = fetchFromGitHub {
-    repo = product;
-    owner = product;
+    repo = "pdfpc";
+    owner = "pdfpc";
     rev = "v${version}";
     sha256 = "0bmy51w6ypz927hxwp5g7wapqvzqmsi3w32rch6i3f94kg1152ck";
   };

pkgs/applications/misc/qmetro/default.nix

···
 { lib, stdenv, fetchurl, qmake4Hook, unzip, qt4 }:
 
 stdenv.mkDerivation rec {
-  name = "${project}-${version}";
-  project = "qmetro";
+  pname = "qmetro";
   version = "0.7.1";
 
   src = fetchurl {
-    url = "mirror://sourceforge/${project}/${name}.zip";
+    url = "mirror://sourceforge/qmetro/qmetro-${version}.zip";
     sha256 = "1zdj87lzcr43gr2h05g17z31pd22n5kxdwbvx7rx656rmhv0sjq5";
   };
 

pkgs/applications/misc/sleepyhead/default.nix

···
 { lib, stdenv, mkDerivation, fetchgit, zlib, libGLU, libX11, qtbase, qtwebkit, qtserialport, wrapQtAppsHook }:
 
-let
-  name = "sleepyhead-${version}";
+mkDerivation {
+  pname = "sleepyhead";
   version = "1.0.0-beta-git";
-in mkDerivation {
-  inherit name;
 
   src = fetchgit {
     url = "https://gitlab.com/sleepyhead/sleepyhead-code.git";

pkgs/applications/misc/slmenu/default.nix

···
 {lib, stdenv, fetchhg}:
-let
-  s =
-  rec {
-    baseName = "slmenu";
-    version = "hg-${date}";
-    date = "2012-02-01";
-    name = "${baseName}-${version}";
+
+stdenv.mkDerivation {
+  pname = "slmenu";
+  version = "hg-2012-02-01";
+
+  src = fetchhg {
     url = "https://bitbucket.org/rafaelgg/slmenu/";
     rev = "7e74fa5db73e8b018da48d50dbbaf11cb5c62d13";
     sha256 = "0zb7mm8344d3xmvrl62psazcabfk75pp083jqkmywdsrikgjagv6";
   };
-  buildInputs = [
-  ];
-in
-stdenv.mkDerivation {
-  inherit (s) name version;
-  inherit buildInputs;
-  src = fetchhg {
-    inherit (s) url sha256;
-  };
   makeFlags = [ "PREFIX=$(out)" ];
-  meta = {
-    inherit (s) version;
+  meta = with lib; {
     description = "A console dmenu-like tool";
-    license = lib.licenses.mit;
-    maintainers = [lib.maintainers.raskin];
-    platforms = lib.platforms.linux;
+    license = licenses.mit;
+    maintainers = with maintainers; [ raskin ];
+    platforms = platforms.linux;
   };
 }

pkgs/applications/misc/tuhi/default.nix

···
 }:
 
 python3Packages.buildPythonApplication rec {
-  name = "tuhi";
+  pname = "tuhi";
   version = "0.5";
 
   format = "other";
 
   src = fetchFromGitHub {
     owner = "tuhiproject";
-    repo = name;
-    rev = "${version}";
+    repo = "tuhi";
+    rev = version;
     sha256 = "17kggm9c423vj7irxx248fjc8sxvkp9w1mgawlx1snrii817p3db";
   };
 

pkgs/applications/misc/urlview/default.nix

···
 { lib, stdenv, fetchurl, ncurses, autoreconfHook }:
 
 stdenv.mkDerivation rec {
-  version    = "0.9";
+  pname = "urlview";
+  _version    = "0.9";
   patchLevel = "19";
-
-  name = "urlview-${version}-${patchLevel}";
+  version = "${_version}-${patchLevel}";
 
   urlBase = "mirror://debian/pool/main/u/urlview/";
 
   src = fetchurl {
-    url = urlBase + "urlview_${version}.orig.tar.gz";
+    url = urlBase + "urlview_${_version}.orig.tar.gz";
     sha256 = "746ff540ccf601645f500ee7743f443caf987d6380e61e5249fc15f7a455ed42";
   };
 
···
   '';
 
   debianPatches = fetchurl {
-    url = urlBase + "urlview_${version}-${patchLevel}.diff.gz";
+    url = urlBase + "urlview_${_version}-${patchLevel}.diff.gz";
     sha256 = "056883c17756f849fb9235596d274fbc5bc0d944fcc072bdbb13d1e828301585";
   };
 

pkgs/applications/misc/xmr-stak/default.nix

···
 in
 
 stdenv'.mkDerivation rec {
-  name = "xmr-stak-${version}";
+  pname = "xmr-stak";
   version = "2.10.8";
 
   src = fetchFromGitHub {

pkgs/applications/misc/zscroll/default.nix

···
 { lib, python3, python3Packages, fetchFromGitHub }:
 
-let version = "1.0"; in
+python3Packages.buildPythonApplication rec {
+  pname = "zscroll";
+  version = "1.0";
 
-python3Packages.buildPythonApplication {
-  name = "zscroll-${version}";
   # don't prefix with python version
   namePrefix = "";
 

pkgs/applications/networking/browsers/chromium/upstream-info.json

···
     }
   },
   "beta": {
-    "version": "100.0.4896.46",
-    "sha256": "1qx22vadv9yd3n52pjn2sr153w70k3sxi2i8f99fdpil0kin8jkx",
-    "sha256bin64": "1g4xygj3946322aill7lk1qf0hi07bjn3awa17pkn1sgbl3gm8nr",
+    "version": "100.0.4896.56",
+    "sha256": "0vdyddxhmkw9bqwx5j19h69swx9ysiipsmcc1sjl0qv8bn8f790z",
+    "sha256bin64": "09h4fxsx0q5b0gn258xnmk11qz7ql8flpn4mq5x201abmv29y856",
     "deps": {
       "gn": {
         "version": "2022-01-21",
···
     }
   },
   "dev": {
-    "version": "101.0.4947.0",
-    "sha256": "176bby8xis0j3ifvxxxjgklvs7yd7v71c5lc18qdjkgzv5qdx0sy",
-    "sha256bin64": "1rkpc25ff8vf1p7znpmaljj8gwcym34qg28b4anv8x9zvwn7w21s",
+    "version": "101.0.4951.7",
+    "sha256": "0xnvbiqi50hgky35qaivcyzfp05nnwfwqrd50dksqkzycl8avb4z",
+    "sha256bin64": "19my3zr9d3w2ypl9cm1xa15vhyv9add1f283alb9fmh2qwhl4scg",
     "deps": {
       "gn": {
         "version": "2022-03-14",

pkgs/applications/networking/cluster/cmctl/default.nix

···
 
 buildGoModule rec {
   pname = "cmctl";
-  version = "1.7.1";
+  version = "1.7.2";
 
   src = fetchFromGitHub {
     owner = "cert-manager";
     repo = "cert-manager";
     rev = "v${version}";
-    sha256 = "sha256-RO7YcGEfAQ9kTxfqgekYf6M5b6Fg64hCPLA/vt6IWp8=";
+    sha256 = "sha256-Hx6MG5GCZyOX0tfpg1bfUT0BOI3p7Mws1VCz2PuUuw8=";
   };
 
   vendorSha256 = "sha256-4zhdpedOmLl/i1G0QCto4ACxguWRZLzOm5HfMBMtvPY=";

pkgs/applications/networking/cluster/helmfile/default.nix

···
 
 buildGoModule rec {
   pname = "helmfile";
-  version = "0.143.1";
+  version = "0.143.3";
 
   src = fetchFromGitHub {
     owner = "roboll";
     repo = "helmfile";
     rev = "v${version}";
-    sha256 = "sha256-eV2+lQVLv+bU/CmFFYM7CLjomXblT0XVZH5HVq0S+WM=";
+    sha256 = "sha256-A0xpXsMWUaJYTzo9O4KkdyjonSGZ+FylTK140pqnJX8=";
   };
 
-  vendorSha256 = "sha256-JHXSEOR/+ON5x0iQgaFsnb9hEDFf5/8TTh4T54qE/HE=";
+  vendorSha256 = "sha256-qolmWat7An4HFm4O5vSCYZe+w79nsRIrnBLJacUCeA4=";
 
   doCheck = false;
 

pkgs/applications/networking/cluster/kubent/default.nix

···
+{ lib, buildGoModule, fetchFromGitHub }:
+
+buildGoModule rec {
+  pname = "kubent";
+  version = "0.5.1";
+
+  src = fetchFromGitHub {
+    owner = "doitintl";
+    repo = "kube-no-trouble";
+    rev = "${version}";
+    sha256 = "0pwb9g1hhfqn3rl87fg6sf07m7aviadljb05bbnd241hhlcyslv6";
+  };
+
+  vendorSha256 = "1z4cvk936l7011fbimsgpw89yqzyikw9jb4184l37mnj9hl5wpcp";
+
+  ldflags = [
+    "-w" "-s"
+    "-X main.version=v${version}"
+  ];
+
+  subPackages = [ "cmd/kubent" ];
+
+  meta = with lib; {
+    homepage = "https://github.com/doitintl/kube-no-trouble";
+    description = "Easily check your cluster for use of deprecated APIs";
+    license = licenses.mit;
+    maintainers = with maintainers; [ peterromfeldhk ];
+  };
+}

pkgs/applications/networking/cluster/werf/default.nix

···
 
 buildGoModule rec {
   pname = "werf";
-  version = "1.2.77";
+  version = "1.2.78";
 
   src = fetchFromGitHub {
     owner = "werf";
     repo = "werf";
     rev = "v${version}";
-    sha256 = "sha256-JmadwNERjexnJN+fBUjgMkvPtAaTbb7GITPsZlx2vik=";
+    sha256 = "sha256-ehrzb7WvkYL8oj2RSzKc1KDagV0zg6vMzgpT2sPyhcI=";
   };
-  vendorSha256 = "sha256-IPQiS1GgNP+k/INv3f3VitoHActC3MrRys905nTSXyI=";
+  vendorSha256 = "sha256-w8ZeAQbZIVOBoRa9fJhXgTeYRCYpkh/U4pwb5u6A9mQ=";
   proxyVendor = true;
 
   nativeBuildInputs = [ pkg-config ];

pkgs/applications/networking/instant-messengers/fractal/default.nix

···
-{ lib, stdenv
+{ stdenv
+, lib
 , fetchFromGitLab
+, fetchpatch
 , nix-update-script
 , meson
 , ninja
···
     rev = version;
     sha256 = "DSNVd9YvI7Dd3s3+M0+wE594tmL1yPNMnD1W9wLhSuw=";
   };
+
+  patches = [
+    # Fix build with meson 0.61
+    # fractal-gtk/res/meson.build:5:0: ERROR: Function does not take positional arguments.
+    (fetchpatch {
+      url = "https://gitlab.gnome.org/GNOME/fractal/-/commit/6fa1a23596d65d94aa889efe725174e6cd2903f0.patch";
+      sha256 = "3OzU9XL2V1VNOkvL1j677K3HNoBqPMQudQDmiDxYfAc=";
+    })
+  ];
 
   cargoDeps = rustPlatform.fetchCargoTarball {
     inherit src;

pkgs/applications/networking/instant-messengers/signal-desktop/default.nix

···
 
 in stdenv.mkDerivation rec {
   pname = "signal-desktop";
-  version = "5.35.0"; # Please backport all updates to the stable channel.
+  version = "5.36.0"; # Please backport all updates to the stable channel.
   # All releases have a limited lifetime and "expire" 90 days after the release.
   # When releases "expire" the application becomes unusable until an update is
   # applied. The expiration date for the current release can be extracted with:
···
 
   src = fetchurl {
     url = "https://updates.signal.org/desktop/apt/pool/main/s/signal-desktop/signal-desktop_${version}_amd64.deb";
-    sha256 = "sha256-2KF2OLq6/vHElgloxn+kgQisJC+HAkpOBfsKfEPW35c=";
+    sha256 = "sha256-x1PUEDq/0B1T14mBs2FuKtcGpJHWOIvHAs8hptpzhZk=";
   };
 
   nativeBuildInputs = [

pkgs/applications/networking/p2p/frostwire/default.nix

···
 
 let
   version = "6.6.7-build-529";
-  name = "frostwire-desktop-${version}";
 
   src = fetchFromGitHub {
     owner = "frostwire";
     repo = "frostwire";
-    rev = name;
+    rev = "frostwire-desktop-${version}";
     sha256 = "03wdj2kr8akzx8m1scvg98132zbaxh81qjdsxn2645b3gahjwz0m";
   };
 
···
 
   # fake build to pre-download deps into fixed-output derivation
   deps = stdenv.mkDerivation {
-    name = "${name}-deps";
-    inherit src;
+    pname = "frostwire-desktop-deps";
+    inherit version src;
     buildInputs = [ gradle_6 perl ];
     buildPhase = ''
       export GRADLE_USER_HOME=$(mktemp -d)
···
     '';
     outputHashAlgo = "sha256";
     outputHashMode = "recursive";
-    outputHash = "11zd98g0d0fdgls4lsskkagwfxyh26spfd6c6g9cahl89czvlg3c";
+    outputHash = "sha256-r6YSrbSJbM3063JrX4tCVKFrJxTaLN4Trc+33jzpwcE=";
   };
 
 in stdenv.mkDerivation {
-  inherit name src;
+  pname = "frostwire-desktop";
+  inherit version src;
 
   nativeBuildInputs = [ makeWrapper ];
   buildInputs = [ gradle_6 ];

pkgs/applications/networking/remote/vmware-horizon-client/default.nix

···
 
 in
 stdenv.mkDerivation {
-  name = "vmware-horizon-client";
+  pname = "vmware-horizon-client";
+  inherit version;
 
   dontUnpack = true;
 

pkgs/applications/office/jameica/default.nix

···
   _version = "2.10.1";
   _build = "482";
   version = "${_version}-${_build}";
-  name = "jameica-${version}";
 
   swtSystem = if stdenv.hostPlatform.system == "i686-linux" then "linux"
   else if stdenv.hostPlatform.system == "x86_64-linux" then "linux64"
···
   };
 in
 stdenv.mkDerivation rec {
-  inherit name version;
+  pname = "jameica";
+  inherit version;
 
   nativeBuildInputs = [ ant jdk makeWrapper ];
   buildInputs = lib.optionals stdenv.isLinux [ gtk2 glib xorg.libXtst ]
···
   '';
 
   installPhase = ''
-    mkdir -p $out/libexec $out/lib $out/bin $out/share/{applications,${name},java}/
+    mkdir -p $out/libexec $out/lib $out/bin $out/share/{applications,jameica-${version},java}/
 
     # copy libraries except SWT
-    cp $(find lib -type f -iname '*.jar' | grep -ve 'swt/.*/swt.jar') $out/share/${name}/
+    cp $(find lib -type f -iname '*.jar' | grep -ve 'swt/.*/swt.jar') $out/share/jameica-${version}/
     # copy platform-specific SWT
-    cp lib/swt/${swtSystem}/swt.jar $out/share/${name}/
+    cp lib/swt/${swtSystem}/swt.jar $out/share/jameica-${version}/
 
     install -Dm644 releases/${_version}-*/jameica/jameica.jar $out/share/java/
     install -Dm644 plugin.xml $out/share/java/
···
     cp ${desktopItem}/share/applications/* $out/share/applications/
 
     makeWrapper ${jre}/bin/java $out/bin/jameica \
-      --add-flags "-cp $out/share/java/jameica.jar:$out/share/${name}/* ${
+      --add-flags "-cp $out/share/java/jameica.jar:$out/share/jameica-${version}/* ${
         lib.optionalString stdenv.isDarwin ''-Xdock:name="Jameica" -XstartOnFirstThread''
       } de.willuhn.jameica.Main" \
       --prefix LD_LIBRARY_PATH : ${lib.makeLibraryPath buildInputs} \

pkgs/applications/radio/rtl-ais/default.nix

···
 { lib, stdenv, fetchFromGitHub, pkg-config, libusb1, rtl-sdr }:
 
 stdenv.mkDerivation {
-  name = "rtl-ais";
+  pname = "rtl-ais";
   version = "0.8.1";
   buildInputs = [ pkg-config rtl-sdr libusb1 ];
 

pkgs/applications/radio/sdrplay/default.nix

···
     else if stdenv.isi686    then "i686"
     else throw "unsupported architecture";
 in stdenv.mkDerivation rec {
-  name = "sdrplay";
+  pname = "sdrplay";
   version = "3.07.1";
 
   src = fetchurl {

pkgs/applications/radio/soapysdrplay/default.nix

···
 { stdenv, lib, fetchFromGitHub, cmake, pkg-config, soapysdr, sdrplay }:
 
 stdenv.mkDerivation {
-  name = "soapysdr-sdrplay3";
-  version = "20210425";
+  pname = "soapysdr-sdrplay3";
+  version = "unstable-2021-04-25";
 
   src = fetchFromGitHub {
     owner = "pothosware";

pkgs/applications/radio/soundmodem/default.nix

···
 { lib, stdenv, fetchurl, pkg-config, alsa-lib, audiofile, gtk2, libxml2 }:
 
 stdenv.mkDerivation rec {
-  name = "soundmodem";
+  pname = "soundmodem";
   version = "0.20";
 
   src = fetchurl {
-    url = "https://archive.org/download/${name}-${version}/${name}-${version}.tar.gz";
+    url = "https://archive.org/download/soundmodem-${version}/soundmodem-${version}.tar.gz";
     sha256 = "156l3wjnh5rcisxb42kcmlf74swf679v4xnj09zy5j74rd4h721z";
   };
 
···
     '';
     #homepage = "http://gna.org/projects/soundmodem"; # official, but "Connection refused"
     homepage = "http://soundmodem.vk4msl.id.au/";
-    downloadPage = "https://archive.org/download/${name}-${version}/${name}-${version}.tar.gz";
+    downloadPage = "https://archive.org/download/${pname}-${version}/${pname}-${version}.tar.gz";
     license = licenses.gpl2Only;
     maintainers = with maintainers; [ ymarkus ];
     platforms = platforms.all;

pkgs/applications/science/biology/ncbi-tools/default.nix

···
 # Another note: you may want the older and deprecated C-libs at ftp://ftp.ncbi.nih.gov/toolbox/ncbi_tools++/2008/Mar_17_2008/NCBI_C_Toolkit/ncbi_c--Mar_17_2008.tar.gz
 
 stdenv.mkDerivation rec {
-  name = "ncbi_tools";
-  ncbi_version = "Dec_31_2008";
+  pname = "ncbi_tools";
+  version = "Dec_31_2008";
   src = fetchurl {
-    url = "ftp://ftp.ncbi.nih.gov/toolbox/ncbi_tools++/2008/${ncbi_version}/ncbi_cxx--${ncbi_version}.tar.gz";
+    url = "ftp://ftp.ncbi.nih.gov/toolbox/ncbi_tools++/2008/${version}/ncbi_cxx--${version}.tar.gz";
     sha256 = "1b2v0dcdqn3bysgdkj57sxmd6s0hc9wpnxssviz399g6plhxggbr";
   };
 

pkgs/applications/science/chemistry/marvin/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "marvin";
-  version = "22.7.0";
+  version = "22.8.0";
 
   src = fetchurl {
     name = "marvin-${version}.deb";
     url = "http://dl.chemaxon.com/marvin/${version}/marvin_linux_${versions.majorMinor version}.deb";
-    sha256 = "sha256-xK4C+0/Qpc2vXPmsI8KuHuDJLmJ5LXdAfRIREE+gkWA=";
+    sha256 = "sha256-dmG2p4KqzjLuuVw+wPWaxVoqOqba8Tx5l44PauWpqv4=";
   };
 
   nativeBuildInputs = [ dpkg makeWrapper ];

pkgs/applications/science/electronics/xcircuit/default.nix

···
 { lib, stdenv, fetchurl, autoreconfHook, automake, pkg-config
 , cairo, ghostscript, ngspice, tcl, tk, xorg, zlib }:
 
-let
+stdenv.mkDerivation rec {
   version = "3.10.12";
-  name = "xcircuit-${version}";
-  inherit (lib) getBin;
-
-in stdenv.mkDerivation {
-  inherit name version;
+  pname = "xcircuit";
 
   src = fetchurl {
-    url = "http://opencircuitdesign.com/xcircuit/archive/${name}.tgz";
+    url = "http://opencircuitdesign.com/xcircuit/archive/xcircuit-${version}.tgz";
     sha256 = "1h1ywc3mr7plvwnhdii2zgnnv5ih2nhyl4qbdjpi83dq0aq1s2mn";
   };
 
···
   configureFlags = [
     "--with-tcl=${tcl}/lib"
     "--with-tk=${tk}/lib"
-    "--with-ngspice=${getBin ngspice}/bin/ngspice"
+    "--with-ngspice=${lib.getBin ngspice}/bin/ngspice"
   ];
 
   buildInputs = with xorg; [ cairo ghostscript libSM libXt libICE libX11 libXpm tcl tk zlib ];

pkgs/applications/science/logic/coq/default.nix

···
    "8.14.0".sha256     = "04y2z0qyvag66zanfyc3f9agvmzbn4lsr0p1l7ck6yjhqx7vbm17";
    "8.14.1".sha256     = "0sx78pgx0qw8v7v2r32zzy3l161zipzq95iacda628girim7psnl";
    "8.15.0".sha256     = "sha256:1ma76wfrpfsl72yh10w1ys2a0vi0mdc2jc79kdc8nrmxkhpw1nxx";
+   "8.15.1".sha256     = "sha256:1dsa04jzkx5pw69pmxn0l55q4w88lg6fvz7clbga0bazzsfnsgd6";
   };
   releaseRev = v: "V${v}";
   fetched = import ../../../../build-support/coq/meta-fetch/default.nix

pkgs/applications/science/logic/z3/4.4.0.nix

···
 { lib, stdenv, fetchFromGitHub, python }:
 
 stdenv.mkDerivation rec {
-  name = "z3-${version}";
+  pname = "z3";
   version = "4.4.0";
 
   src = fetchFromGitHub {

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

···
 { lib, stdenv, fetchurl, sbcl, libX11, libXpm, libICE, libSM, libXt, libXau, libXdmcp }:
 
-let
+stdenv.mkDerivation rec {
+  pname = "fricas";
   version = "1.3.7";
-  name = "fricas-" + version;
-in
-stdenv.mkDerivation {
-  inherit name;
 
   src = fetchurl {
-    url = "mirror://sourceforge/fricas/fricas/${version}/${name}-full.tar.bz2";
+    url = "mirror://sourceforge/fricas/fricas/${version}/fricas-${version}-full.tar.bz2";
     sha256 = "sha256-cOqMvSe3ef/ZeVy5cj/VU/aTRtxgfxZfRbE4lWE5TU4=";
   };
 

pkgs/applications/science/math/scilab-bin/default.nix

···
 { stdenv, fetchurl, lib, xorg }:
 
 let
-  name = "scilab-bin-${ver}";
-
-  ver = "6.1.1";
-
-  badArch = throw "${name} requires i686-linux or x86_64-linux";
+  badArch = throw "scilab-bin requires i686-linux or x86_64-linux";
 
   architecture =
     if stdenv.hostPlatform.system == "i686-linux" then
···
     else
       badArch;
 in
-stdenv.mkDerivation {
-  inherit name;
+stdenv.mkDerivation rec {
+  pname = "scilab-bin";
+  version = "6.1.1";
 
   src = fetchurl {
-    url = "https://www.scilab.org/download/${ver}/scilab-${ver}.bin.linux-${architecture}.tar.gz";
+    url = "https://www.scilab.org/download/${version}/scilab-${version}.bin.linux-${architecture}.tar.gz";
     sha256 =
       if stdenv.hostPlatform.system == "i686-linux" then
         "0fgjc2ak3b2qi6yin3fy50qwk2bcj0zbz1h4lyyic9n1n1qcliib"
···
     sed -i 's|\$(/bin/|$(|g' bin/scilab
     sed -i 's|/usr/bin/||g' bin/scilab
 
-    sci="$out/opt/scilab-${ver}"
+    sci="$out/opt/scilab-${version}"
     fullLibPath="$sci/lib/scilab:$sci/lib/thirdparty:$libPath"
     fullLibPath="$fullLibPath:$sci/lib/thirdparty/redist"
 
···
   '';
 
   installPhase = ''
-    mkdir -p "$out/opt/scilab-${ver}"
-    cp -r . "$out/opt/scilab-${ver}/"
+    mkdir -p "$out/opt/scilab-${version}"
+    cp -r . "$out/opt/scilab-${version}/"
 
     # Create bin/ dir
     mkdir "$out/bin"
 
     # Creating executable symlinks
-    ln -s "$out/opt/scilab-${ver}/bin/scilab" "$out/bin/scilab"
-    ln -s "$out/opt/scilab-${ver}/bin/scilab-cli" "$out/bin/scilab-cli"
-    ln -s "$out/opt/scilab-${ver}/bin/scilab-adv-cli" "$out/bin/scilab-adv-cli"
+    ln -s "$out/opt/scilab-${version}/bin/scilab" "$out/bin/scilab"
+    ln -s "$out/opt/scilab-${version}/bin/scilab-cli" "$out/bin/scilab-cli"
+    ln -s "$out/opt/scilab-${version}/bin/scilab-adv-cli" "$out/bin/scilab-adv-cli"
 
     # Creating desktop config dir
     mkdir -p "$out/share/applications"
 
     # Moving desktop config files
-    mv $out/opt/scilab-${ver}/share/applications/*.desktop $out/share/applications
+    mv $out/opt/scilab-${version}/share/applications/*.desktop $out/share/applications
 
     # Fixing Exec paths and launching each app with a terminal
-    sed -i -e "s|Exec=|Exec=$out/opt/scilab-${ver}/bin/|g" \
+    sed -i -e "s|Exec=|Exec=$out/opt/scilab-${version}/bin/|g" \
            -e "s|Terminal=.*$|Terminal=true|g" $out/share/applications/*.desktop
 
     # Moving icons to the appropriate locations
-    for path in $out/opt/scilab-${ver}/share/icons/hicolor/*/*/*
+    for path in $out/opt/scilab-${version}/share/icons/hicolor/*/*/*
     do
-      newpath=$(echo $path | sed 's|/opt/scilab-${ver}||g')
+      newpath=$(echo $path | sed 's|/opt/scilab-${version}||g')
       filename=$(echo $path | sed 's|.*/||g')
       dir=$(echo $newpath | sed "s|$filename||g")
       mkdir -p $dir
···
     done
 
     # Removing emptied folders
-    rm -rf $out/opt/scilab-${ver}/share/{applications,icons}
+    rm -rf $out/opt/scilab-${version}/share/{applications,icons}
 
     # Moving other share/ folders
-    mv $out/opt/scilab-${ver}/share/{appdata,locale,mime} $out/share
+    mv $out/opt/scilab-${version}/share/{appdata,locale,mime} $out/share
   '';
 
   meta = {

pkgs/applications/science/misc/fityk/default.nix

···
 { lib, stdenv, fetchFromGitHub, autoreconfHook, wxGTK30, boost, lua, zlib, bzip2
 , xylib, readline, gnuplot, swig3 }:
 
-let
-  name    = "fityk";
+stdenv.mkDerivation rec {
+  pname = "fityk";
   version = "1.3.1";
-in
-stdenv.mkDerivation {
-  name = "${name}-${version}";
 
   src = fetchFromGitHub {
     owner = "wojdyr";

pkgs/applications/terminal-emulators/rxvt-unicode-plugins/urxvt-font-size/default.nix

···
 { lib, stdenv, fetchFromGitHub, xrdb, xlsfonts }:
 
 stdenv.mkDerivation rec {
-  name = "urxvt-font-size";
+  pname = "urxvt-font-size";
   version = "1.3";
 
   src = fetchFromGitHub {

pkgs/applications/terminal-emulators/termonad/default.nix

···
 let
   termonadEnv = haskellPackages.ghcWithPackages (self: [ self.termonad ] ++ packages self);
 in stdenv.mkDerivation {
-  name = "termonad-with-packages-${termonadEnv.version}";
+  pname = "termonad-with-packages";
+  inherit (termonadEnv) version;
 
   nativeBuildInputs = [ makeWrapper ];
 

pkgs/applications/version-management/git-and-tools/bfg-repo-cleaner/default.nix

···
 { lib, stdenv, fetchurl, jre, makeWrapper }:
 
-let
+stdenv.mkDerivation rec {
+  pname = "bfg-repo-cleaner";
   version = "1.13.0";
+
   jarName = "bfg-${version}.jar";
-  mavenUrl = "mirror://maven/com/madgag/bfg/${version}/${jarName}";
-in
-  stdenv.mkDerivation {
-    inherit version jarName;
 
-    name = "bfg-repo-cleaner-${version}";
+  src = fetchurl {
+    url = "mirror://maven/com/madgag/bfg/${version}/${jarName}";
+    sha256 = "1kn84rsvms1v5l1j2xgrk7dc7mnsmxkc6sqd94mnim22vnwvl8mz";
+  };
 
-    src = fetchurl {
-      url = mavenUrl;
-      sha256 = "1kn84rsvms1v5l1j2xgrk7dc7mnsmxkc6sqd94mnim22vnwvl8mz";
-    };
+  nativeBuildInputs = [ makeWrapper ];
+  buildInputs = [ jre ];
 
-    nativeBuildInputs = [ makeWrapper ];
-    buildInputs = [ jre ];
-
-    dontUnpack = true;
+  dontUnpack = true;
 
-    installPhase = ''
-      mkdir -p $out/share/java
-      mkdir -p $out/bin
-      cp $src $out/share/java/$jarName
-      makeWrapper "${jre}/bin/java" $out/bin/bfg --add-flags "-cp $out/share/java/$jarName com.madgag.git.bfg.cli.Main"
-    '';
+  installPhase = ''
+    mkdir -p $out/share/java
+    mkdir -p $out/bin
+    cp $src $out/share/java/$jarName
+    makeWrapper "${jre}/bin/java" $out/bin/bfg --add-flags "-cp $out/share/java/$jarName com.madgag.git.bfg.cli.Main"
+  '';
 
-    meta = with lib; {
-      homepage = "https://rtyley.github.io/bfg-repo-cleaner/";
-      # Descriptions taken with minor modification from the homepage of bfg-repo-cleaner
-      description = "Removes large or troublesome blobs in a git repository like git-filter-branch does, but faster";
-      longDescription = ''
-        The BFG is a simpler, faster alternative to git-filter-branch for
-        cleansing bad data out of your Git repository history, in particular removing
-        crazy big files and removing passwords, credentials, and other private data.
+  meta = with lib; {
+    homepage = "https://rtyley.github.io/bfg-repo-cleaner/";
+    # Descriptions taken with minor modification from the homepage of bfg-repo-cleaner
+    description = "Removes large or troublesome blobs in a git repository like git-filter-branch does, but faster";
+    longDescription = ''
+      The BFG is a simpler, faster alternative to git-filter-branch for
+      cleansing bad data out of your Git repository history, in particular removing
+      crazy big files and removing passwords, credentials, and other private data.
 
-        The git-filter-branch command is enormously powerful and can do things
-        that the BFG can't - but the BFG is much better for the tasks above, because
-        it's faster (10-720x), simpler (dedicated to just removing things), and
-        beautiful (can use Scala instead of bash to script customizations).
-      '';
-      license = licenses.gpl3;
-      maintainers = [ maintainers.changlinli ];
-      platforms = platforms.unix;
-      downloadPage = "https://mvnrepository.com/artifact/com.madgag/bfg/${version}";
-    };
+      The git-filter-branch command is enormously powerful and can do things
+      that the BFG can't - but the BFG is much better for the tasks above, because
+      it's faster (10-720x), simpler (dedicated to just removing things), and
+      beautiful (can use Scala instead of bash to script customizations).
+    '';
+    license = licenses.gpl3;
+    maintainers = [ maintainers.changlinli ];
+    platforms = platforms.unix;
+    downloadPage = "https://mvnrepository.com/artifact/com.madgag/bfg/${version}";
+  };
 
-  }
+}

pkgs/applications/version-management/git-and-tools/git-secret/default.nix

···
 { stdenv, lib, fetchFromGitHub, makeWrapper, git, gnupg, gawk }:
 
-let
+stdenv.mkDerivation rec {
+  pname = "git-secret";
   version = "0.4.0";
-  repo = "git-secret";
-
-in stdenv.mkDerivation {
-  name = "${repo}-${version}";
 
   src = fetchFromGitHub {
-    inherit repo;
+    repo = "git-secret";
     owner = "sobolevn";
     rev = "v${version}";
     sha256 = "sha256-Mtuj+e/yCDr4XkmYkWUFJB3cqOT5yOMOq9P/QJV1S80=";

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

···
 
 buildGoPackage rec {
   pname = "gitea";
-  version = "1.16.4";
+  version = "1.16.5";
 
   # not fetching directly from the git repo, because that lacks several vendor files for the web UI
   src = fetchurl {
     url = "https://github.com/go-gitea/gitea/releases/download/v${version}/gitea-src-${version}.tar.gz";
-    sha256 = "sha256-7zlreX05pkhn381FMgQ8Nj3OP+BUr6o3u5f4ouo/Khg=";
+    sha256 = "sha256-2aqy6DV8oaIur/syg1bk41Wo+FGk3m+05+tUyoDwGHs=";
   };
 
   unpackPhase = ''

pkgs/applications/video/p2pvc/default.nix

···
 { lib, stdenv, pkg-config, fetchFromGitHub, opencv2, ncurses, portaudio }:
 
 stdenv.mkDerivation {
-  name = "p2pvc";
+  pname = "p2pvc";
+  version = "unstable-2015-02-12";
 
   nativeBuildInputs = [ pkg-config ];
   buildInputs = [ opencv2 ncurses portaudio ];

pkgs/applications/virtualization/OVMF/default.nix

···
 in
 
 edk2.mkDerivation projectDscPath {
-  name = "OVMF-${version}";
+  pname = "OVMF";
+  inherit version;
 
   outputs = [ "out" "fd" ];
 

pkgs/applications/virtualization/containerd/default.nix

···
 
 buildGoModule rec {
   pname = "containerd";
-  version = "1.6.1";
+  version = "1.6.2";
 
   src = fetchFromGitHub {
     owner = "containerd";
     repo = "containerd";
     rev = "v${version}";
-    sha256 = "sha256-NOFDUOypq/1ePM8rdK2cDnH1LsSZJ7eQOzDc5h4/PvY=";
+    sha256 = "sha256-l/9jOvZ4nn/wy+XPRoT1lojfGvPEXhPz2FJjLpZ/EE8=";
   };
 
   vendorSha256 = null;

pkgs/applications/virtualization/crun/default.nix

···
 in
 stdenv.mkDerivation rec {
   pname = "crun";
-  version = "1.4.3";
+  version = "1.4.4";
 
   src = fetchFromGitHub {
     owner = "containers";
     repo = pname;
     rev = version;
-    sha256 = "sha256-5q8HirGOPsbaJ7JoLa4DRYkZX3kucWOZ633nzx4zVhg=";
+    sha256 = "sha256-ITUj905ZSdCH0mcw8tubyVKqI6p/oNcC4OW7/NbkR5o=";
     fetchSubmodules = true;
   };
 

pkgs/applications/virtualization/docker/default.nix

···
   # Get revisions from
   # https://github.com/moby/moby/tree/${version}/hack/dockerfile/install/*
   docker_20_10 = callPackage dockerGen rec {
-    version = "20.10.13";
+    version = "20.10.14";
     rev = "v${version}";
     sha256 = "sha256-eDwgqFx4io++SMOjhxMxVzqzcOgOnv6Xe/qmmPCvZts=";
     moby-src = fetchFromGitHub {
       owner = "moby";
       repo = "moby";
       rev = "v${version}";
-      sha256 = "sha256-ajceIdMM8yAa+bvTjRwZ/zF7yTLF2LhGmbrweWni7hM=";
+      sha256 = "sha256-I5oxpFLH789I2Sb29OXDaM4fCbQT/KvPq0DYcAVp0aI=";
     };
     runcRev = "v1.0.3";
     runcSha256 = "sha256-Tl/JKbIpao+FCjngPzaVkxse50zo3XQ9Mg/AdkblMcI=";
-    containerdRev = "v1.5.10";
-    containerdSha256 = "sha256-ee0dwWSGedo08omKOmZtW5qQ1J5M9Mm+kZHq7a+zyT4=";
+    containerdRev = "v1.5.11";
+    containerdSha256 = "sha256-YzFtv6DIjImSK0SywxhZrEeEmCnHTceAi3pfwnPubKg=";
     tiniRev = "v0.19.0";
     tiniSha256 = "sha256-ZDKu/8yE5G0RYFJdhgmCdN3obJNyRWv6K/Gd17zc1sI=";
   };

pkgs/applications/virtualization/docker/gc.nix

···
 with lib;
 
 stdenv.mkDerivation rec {
-  name = "docker-gc-${rev}";
-  rev = "b0cc52aa3da2e2ac0080794e0be6e674b1f063fc";
+  pname = "docker-gc";
+  version = "unstable-2015-10-5";
 
   src = fetchFromGitHub {
-    inherit rev;
     owner = "spotify";
     repo = "docker-gc";
+    rev = "b0cc52aa3da2e2ac0080794e0be6e674b1f063fc";
     sha256 = "07wf9yn0f771xkm3x12946x5rp83hxjkd70xgfgy35zvj27wskzm";
   };
 

pkgs/applications/virtualization/docker/proxy.nix

···
 { lib, buildGoPackage, fetchFromGitHub }:
 
 buildGoPackage rec {
-  name = "docker-proxy-${rev}";
-  rev = "fa125a3512ee0f6187721c88582bf8c4378bd4d7";
+  pname = "docker-proxy";
+  version = "unstable-2020-12-15";
 
   src = fetchFromGitHub {
-    inherit rev;
     owner = "docker";
     repo = "libnetwork";
+    rev = "fa125a3512ee0f6187721c88582bf8c4378bd4d7";
     sha256 = "1r47y0gww3j7fas4kgiqbhrz5fazsx1c6sxnccdfhj8fzik77s9y";
   };
 

pkgs/applications/virtualization/gvisor/containerd-shim.nix

···
 { lib, fetchFromGitHub, buildGoModule }:
 
 buildGoModule rec {
-  name = "gvisor-containerd-shim-${version}";
-  version = "2019-10-09";
+  pname = "gvisor-containerd-shim";
+  version = "unstable-2019-10-09";
 
   src = fetchFromGitHub {
     owner  = "google";

pkgs/applications/virtualization/gvisor/default.nix

···
   };
 
 in buildBazelPackage rec {
-  name = "gvisor-${version}";
+  pname = "gvisor";
   version = "20210518.0";
 
   src = fetchFromGitHub {

pkgs/applications/virtualization/qemu/utils.nix

···
 { stdenv, installShellFiles, qemu }:
 
 stdenv.mkDerivation rec {
-  name = "qemu-utils-${version}";
-  version = qemu.version;
+  pname = "qemu-utils";
+  inherit (qemu) version;
 
   nativeBuildInputs = [ installShellFiles ];
   buildInputs = [ qemu ];

pkgs/applications/virtualization/virt-viewer/default.nix

···
 with lib;
 
 stdenv.mkDerivation rec {
-  baseName = "virt-viewer";
+  pname = "virt-viewer";
   version = "11.0";
-  name = "${baseName}-${version}";
 
   src = fetchurl {
-    url = "http://virt-manager.org/download/sources/${baseName}/${name}.tar.xz";
+    url = "https://releases.pagure.org/virt-viewer/virt-viewer-${version}.tar.xz";
     sha256 = "sha256-pD+iMlxMHHelyMmAZaww7wURohrJjlkPIjQIabrZq9A=";
   };
 

pkgs/applications/window-managers/clfswm/default.nix

···
 , makeWrapper }:
 
 stdenv.mkDerivation {
-  name = "clfswm";
+  pname = "clfswm";
+  version = "unstable-2016-11-12";
 
   src = fetchgit {
     url = "https://gitlab.common-lisp.net/clfswm/clfswm.git";
-    rev = "refs/heads/master";
+    rev = "3c7721dba6339ebb4f8c8d7ce2341740fa86f837";
     sha256 = "0hynzh3a1zr719cxfb0k4cvh5lskzs616hwn7p942isyvhwzhynd";
   };
 

pkgs/applications/window-managers/taffybar/default.nix

···
     self.taffybar
   ] ++ packages self);
 in stdenv.mkDerivation {
-  name = "taffybar-with-packages-${taffybarEnv.version}";
+  pname = "taffybar-with-packages";
+  inherit (taffybarEnv) version;
 
   nativeBuildInputs = [ makeWrapper ];
 

pkgs/applications/window-managers/xmonad/wrapper.nix

···
 let
 xmonadEnv = ghcWithPackages (self: [ self.xmonad ] ++ packages self);
 in stdenv.mkDerivation {
-  name = "xmonad-with-packages-${xmonadEnv.version}";
+  pname = "xmonad-with-packages";
+  inherit (xmonadEnv) version;
 
   nativeBuildInputs = [ makeWrapper ];
 

pkgs/build-support/build-fhs-userenv-bubblewrap/env.nix

···
     export PATH="/run/wrappers/bin:/usr/bin:/usr/sbin:$PATH"
     export TZDIR='/etc/zoneinfo'
 
+    # XDG_DATA_DIRS is used by pressure-vessel (steam proton) and vulkan loaders to find the corresponding icd
+    export XDG_DATA_DIRS=$XDG_DATA_DIRS''${XDG_DATA_DIRS:+:}/run/opengl-driver/share:/run/opengl-driver-32/share
+
     # Force compilers and other tools to look in default search paths
     unset NIX_ENFORCE_PURITY
     export NIX_CC_WRAPPER_TARGET_HOST_${stdenv.cc.suffixSalt}=1

pkgs/build-support/build-fhs-userenv/env.nix

···
     export PATH="/run/wrappers/bin:/usr/bin:/usr/sbin:$PATH"
     export TZDIR='/etc/zoneinfo'
 
+    # XDG_DATA_DIRS is used by pressure-vessel (steam proton) and vulkan loaders to find the corresponding icd
+    export XDG_DATA_DIRS=$XDG_DATA_DIRS''${XDG_DATA_DIRS:+:}/run/opengl-driver/share:/run/opengl-driver-32/share
+
     # Force compilers and other tools to look in default search paths
     unset NIX_ENFORCE_PURITY
     export NIX_CC_WRAPPER_TARGET_HOST_${stdenv.cc.suffixSalt}=1

pkgs/data/documentation/std-man-pages/default.nix

···
 { stdenv, lib, fetchurl }:
 
-stdenv.mkDerivation {
-  name = "std-man-pages-4.4.0";
+stdenv.mkDerivation rec {
+  pname = "std-man-pages";
+  version = "4.4.0";
 
   src = fetchurl {
-    url = "mirror://gcc/libstdc++/doxygen/libstdc++-man.4.4.0.tar.bz2";
+    url = "mirror://gcc/libstdc++/doxygen/libstdc++-man.${version}.tar.bz2";
     sha256 = "0153py77ll759jacq41dp2z2ksr08pdcfic0rwjd6pr84dk89y9v";
   };
 

pkgs/data/fonts/sarasa-gothic/default.nix

···
 { lib, fetchurl, libarchive }:
 
 let
-  version = "0.36.0";
+  version = "0.36.1";
 in fetchurl {
   name = "sarasa-gothic-${version}";
 
   # Use the 'ttc' files here for a smaller closure size.
   # (Using 'ttf' files gives a closure size about 15x larger, as of November 2021.)
   url = "https://github.com/be5invis/Sarasa-Gothic/releases/download/v${version}/sarasa-gothic-ttc-${version}.7z";
-  sha256 = "sha256-ENBF7dVFp9lrGGRwNIB0Yg7y1F5XbVivgD2e9pLZQwQ=";
+  sha256 = "sha256-w8PVDvbnHFZF7/X4EzO0IJsEKMC7c+GPng1sn8Q8G14=";
 
   recursiveHash = true;
   downloadToTemp = true;

pkgs/data/icons/faba-icon-theme/default.nix

···
 { lib, stdenv, fetchFromGitHub, meson, ninja, python3, gtk3, pantheon, gnome-icon-theme, hicolor-icon-theme }:
 
 stdenv.mkDerivation rec {
-  name = "${package-name}-${version}";
-  package-name = "faba-icon-theme";
+  pname = "faba-icon-theme";
   version = "4.3";
 
   src = fetchFromGitHub {
     owner = "moka-project";
-    repo = package-name;
+    repo = "faba-icon-theme";
     rev = "v${version}";
     sha256 = "0xh6ppr73p76z60ym49b4d0liwdc96w41cc5p07d48hxjsa6qd6n";
   };

pkgs/data/icons/tango-icon-theme/default.nix

···
 }:
 
 stdenv.mkDerivation rec {
-  name = "tango-icon-theme-0.8.90";
+  pname = "tango-icon-theme";
+  version = "0.8.90";
 
   src = fetchurl {
-    url = "http://tango.freedesktop.org/releases/${name}.tar.gz";
+    url = "http://tango.freedesktop.org/releases/tango-icon-theme-${version}.tar.gz";
     sha256 = "13n8cpml71w6zfm2jz5fa7r1z18qlzk4gv07r6n1in2p5l1xi63f";
   };
 

pkgs/data/misc/brise/default.nix

···
 { lib, stdenv, fetchFromGitHub, librime }:
 
 stdenv.mkDerivation {
-  name = "brise-unstable-2017-09-16";
+  pname = "brise";
+  version = "unstable-2017-09-16";
 
   src = fetchFromGitHub {
     owner = "rime";

pkgs/data/misc/miscfiles/default.nix

···
 {lib, stdenv, fetchurl}:
 
 stdenv.mkDerivation rec {
-  name = "miscfiles-1.5";
+  pname = "miscfiles";
+  version = "1.5";
 
   src = fetchurl {
-    url = "mirror://gnu/miscfiles/${name}.tar.gz";
+    url = "mirror://gnu/miscfiles/miscfiles-${version}.tar.gz";
     sha256 = "005588vfrwx8ghsdv9p7zczj9lbc9a3r4m5aphcaqv8gif4siaka";
   };
 

pkgs/data/misc/shared-desktop-ontologies/default.nix

···
 { lib, stdenv, fetchurl, cmake }:
 
 stdenv.mkDerivation rec {
-  name = "shared-desktop-ontologies-0.11.0";
+  pname = "shared-desktop-ontologies";
+  version = "0.11.0";
 
   src = fetchurl {
-    url = "mirror://sourceforge/oscaf/${name}.tar.bz2";
+    url = "mirror://sourceforge/oscaf/shared-desktop-ontologies-${version}.tar.bz2";
     sha256 = "1m5vnijg7rnwg41vig2ckg632dlczzdab1gsq51g4x7m9k1fdbw2";
   };
 

pkgs/data/themes/arc/default.nix

···
 , sassc
 , meson
 , ninja
-, pkg-config
-, gtk3
 , glib
 , gnome
 , gtk-engine-murrine
-, optipng
 , inkscape
 , cinnamon
+, makeFontsConf
+, python3
 }:
 
 stdenv.mkDerivation rec {
   pname = "arc-theme";
-  version = "20211018";
+  version = "20220223";
 
   src = fetchFromGitHub {
     owner = "jnsh";
     repo = pname;
     rev = version;
-    sha256 = "1rrxm5b7l8kq1h0lm08ck54xljzm8w573mxx904n3rhdg3ri9d63";
+    sha256 = "sha256-qsZdXDNxT1/gIlkUsC1cfVrULApC+dHreBXXjVTJQiA=";
   };
 
   nativeBuildInputs = [
     meson
     ninja
-    pkg-config
     sassc
-    optipng
     inkscape
-    gtk3
     glib # for glib-compile-resources
+    python3
   ];
 
   propagatedUserEnvPkgs = [
···
     gtk-engine-murrine
   ];
 
+  postPatch = ''
+    patchShebangs meson/install-file.py
+  '';
+
   preBuild = ''
     # Shut up inkscape's warnings about creating profile directory
-    export HOME="$NIX_BUILD_ROOT"
+    export HOME="$TMPDIR"
   '';
 
+  # Fontconfig error: Cannot load default config file: No such file: (null)
+  FONTCONFIG_FILE = makeFontsConf { fontDirectories = [ ]; };
+
   mesonFlags = [
-    "-Dthemes=cinnamon,gnome-shell,gtk2,gtk3,plank,xfwm,metacity"
-    "-Dvariants=light,darker,dark,lighter"
+    # "-Dthemes=cinnamon,gnome-shell,gtk2,gtk3,plank,xfwm,metacity"
+    # "-Dvariants=light,darker,dark,lighter"
     "-Dcinnamon_version=${cinnamon.cinnamon-common.version}"
     "-Dgnome_shell_version=${gnome.gnome-shell.version}"
-    "-Dgtk3_version=${gtk3.version}"
     # You will need to patch gdm to make use of this.
     "-Dgnome_shell_gresource=true"
   ];

pkgs/data/themes/dracula-theme/default.nix

···
   installPhase = ''
     runHook preInstall
     mkdir -p $out/share/themes/${themeName}
-    cp -a {assets,cinnamon,gnome-shell,gtk-2.0,gtk-3.0,gtk-3.20,index.theme,metacity-1,unity,xfwm4} $out/share/themes/${themeName}
+    cp -a {assets,cinnamon,gnome-shell,gtk-2.0,gtk-3.0,gtk-3.20,gtk-4.0,index.theme,metacity-1,unity,xfwm4} $out/share/themes/${themeName}
 
     cp -a kde/{color-schemes,plasma} $out/share/
     cp -a kde/kvantum $out/share/Kvantum

pkgs/desktops/gnome/apps/gnome-notes/default.nix

···
-{ lib, stdenv
+{ stdenv
+, lib
 , meson
 , ninja
 , gettext
 , fetchurl
+, fetchpatch
 , pkg-config
 , wrapGAppsHook
 , itstool
···
     url = "mirror://gnome/sources/bijiben/${lib.versions.major version}/bijiben-${version}.tar.xz";
     sha256 = "1gvvb2klkzbmyzwkjgmscdiqcl8lyz9b0rxb4igjz079csq6z805";
   };
+
+  patches = [
+    # Fix build with meson 0.61
+    # data/appdata/meson.build:3:5: ERROR: Function does not take positional arguments.
+    (fetchpatch {
+      url = "https://gitlab.gnome.org/GNOME/gnome-notes/-/commit/994af76ce5144062d55d141129bf6bf5fab002ee.patch";
+      sha256 = "sha256-z7dPOLZzaqvdqUIDy6+V3dKossRbG0EDjBu2oJCF6b4=";
+    })
+  ];
 
   doCheck = true;
 

pkgs/desktops/gnome/core/gnome-dictionary/default.nix

···
-{ lib, stdenv, fetchurl, meson, ninja, pkg-config, desktop-file-utils, appstream-glib, libxslt
-, libxml2, gettext, itstool, wrapGAppsHook, docbook_xsl, docbook_xml_dtd_43
-, gnome, gtk3, glib, gsettings-desktop-schemas }:
+{ stdenv
+, lib
+, fetchurl
+, fetchpatch
+, meson
+, ninja
+, pkg-config
+, desktop-file-utils
+, appstream-glib
+, libxslt
+, libxml2
+, gettext
+, itstool
+, wrapGAppsHook
+, docbook_xsl
+, docbook_xml_dtd_43
+, gnome
+, gtk3
+, glib
+, gsettings-desktop-schemas
+}:
 
 stdenv.mkDerivation rec {
   pname = "gnome-dictionary";
···
     sha256 = "1d8dhcfys788vv27v34i3s3x3jdvdi2kqn2a5p8c937a9hm0qr9f";
   };
 
-  doCheck = true;
+  patches = [
+    # Fix test dependencies with meson 0.57, can be removed on next bump
+    # We need to explicitly depend on the generated files.
+    (fetchpatch {
+      url = "https://gitlab.gnome.org/GNOME/gnome-dictionary/-/commit/87c026cfe4acbcfc62d15950f88a71d8d9678c7e.patch";
+      sha256 = "tKesWeOK3OqOxrXm4dZvCZHHdTD7AQbYDjtYDCsLd3A=";
+    })
+    # Fix build with meson 0.61, can be removed on next bump
+    # data/appdata/meson.build:3:5: ERROR: Function does not take positional arguments.
+    (fetchpatch {
+      url = "https://gitlab.gnome.org/GNOME/gnome-dictionary/-/commit/cf3f8a67cd6f3059c555ed9cf0f5fba10abb7f68.patch";
+      sha256 = "cIRM6ACqsnEo2JWYvr6EBye5o0BudugZMShCe1U5hz8=";
+    })
+  ];
 
   nativeBuildInputs = [
-    meson ninja pkg-config wrapGAppsHook libxml2 gettext itstool
-    desktop-file-utils appstream-glib libxslt docbook_xsl docbook_xml_dtd_43
+    meson
+    ninja
+    pkg-config
+    wrapGAppsHook
+    libxml2
+    gettext
+    itstool
+    desktop-file-utils
+    appstream-glib
+    libxslt
+    docbook_xsl
+    docbook_xml_dtd_43
+  ];
+
+  buildInputs = [
+    gtk3
+    glib
+    gsettings-desktop-schemas
+    gnome.adwaita-icon-theme
   ];
-  buildInputs = [ gtk3 glib gsettings-desktop-schemas gnome.adwaita-icon-theme ];
+
+  doCheck = true;
 
   passthru = {
     updateScript = gnome.updateScript {

pkgs/desktops/gnome/core/gucharmap/default.nix

···
 , pkg-config
 , python3
 , gtk3
-, adwaita-icon-theme
+, pcre2
 , glib
 , desktop-file-utils
 , gtk-doc
···
   };
 in stdenv.mkDerivation rec {
   pname = "gucharmap";
-  version = "14.0.0";
+  version = "14.0.2";
 
   outputs = [ "out" "lib" "dev" "devdoc" ];
 
···
     owner = "GNOME";
     repo = pname;
     rev = version;
-    sha256 = "sha256-d283zVRH42NZNq+vGmItN3ZBrRrl9gpYDco7osm3RoY=";
+    sha256 = "sha256-gyOm/S0ae0kX4AFUiglqyGRGB8C/KUuaG/dr/Wf1ug0=";
   };
 
   nativeBuildInputs = [
···
     gtk3
     glib
     gsettings-desktop-schemas
-    adwaita-icon-theme
+    pcre2
   ];
 
   mesonFlags = [

pkgs/desktops/gnome/games/gnome-mahjongg/default.nix

···
-{ lib, stdenv, fetchurl, pkg-config, gnome, gtk3, wrapGAppsHook
-, librsvg, gettext, itstool, libxml2
-, meson, ninja, glib, vala, desktop-file-utils
+{ stdenv
+, lib
+, fetchurl
+, fetchpatch
+, pkg-config
+, gnome
+, gtk3
+, wrapGAppsHook
+, librsvg
+, gettext
+, itstool
+, libxml2
+, meson
+, ninja
+, glib
+, vala
+, desktop-file-utils
 }:
 
 stdenv.mkDerivation rec {
···
     sha256 = "144ia3zn9rhwa1xbdkvsz6m0dsysl6mxvqw9bnrlh845hmyy9cfj";
   };
 
+  patches = [
+    # Fix build with meson 0.61
+    # data/meson.build:24:0: ERROR: Function does not take positional arguments.
+    # data/meson.build:45:0: ERROR: Function does not take positional arguments.
+    (fetchpatch {
+      url = "https://gitlab.gnome.org/GNOME/gnome-mahjongg/-/commit/a2037b0747163601a5d5b57856d037eecf3a4db7.patch";
+      sha256 = "Wcder6Y9H6c1f8I+IPDvST3umaCU21HgxfXn809JDz0=";
+    })
+  ];
+
   nativeBuildInputs = [
-    meson ninja vala desktop-file-utils
-    pkg-config gnome.adwaita-icon-theme
-    libxml2 itstool gettext wrapGAppsHook
+    meson
+    ninja
+    vala
+    desktop-file-utils
+    pkg-config
+    gnome.adwaita-icon-theme
+    libxml2
+    itstool
+    gettext
+    wrapGAppsHook
     glib # for glib-compile-schemas
   ];
+
   buildInputs = [
     glib
     gtk3

pkgs/desktops/gnome/games/gnome-tetravex/default.nix

···
-{ lib, stdenv, fetchurl, pkg-config, gnome, gtk3, wrapGAppsHook
-, libxml2, gettext, itstool, meson, ninja, python3
-, vala, desktop-file-utils
+{ stdenv
+, lib
+, fetchurl
+, fetchpatch
+, pkg-config
+, gnome
+, gtk3
+, wrapGAppsHook
+, libxml2
+, gettext
+, itstool
+, meson
+, ninja
+, python3
+, vala
+, desktop-file-utils
 }:
 
 stdenv.mkDerivation rec {
···
     sha256 = "06wihvqp2p52zd2dnknsc3rii69qib4a30yp15h558xrg44z3k8z";
   };
 
-  passthru = {
-    updateScript = gnome.updateScript { packageName = "gnome-tetravex"; attrPath = "gnome.gnome-tetravex"; };
-  };
+  patches = [
+    # Fix build with meson 0.61
+    # data/meson.build:37:0: ERROR: Function does not take positional arguments.
+    # data/meson.build:59:0: ERROR: Function does not take positional arguments.
+    # Taken from https://gitlab.gnome.org/GNOME/gnome-tetravex/-/merge_requests/20
+    (fetchpatch {
+      url = "https://gitlab.gnome.org/GNOME/gnome-tetravex/-/commit/80912d06f5e588f6aca966fa516103275e58d94e.patch";
+      sha256 = "2+nFw5sJzbInibKaq3J10Ufbl3CnZWlgnUtzRTZ5G0I=";
+    })
+  ];
 
   nativeBuildInputs = [
-    wrapGAppsHook itstool libxml2 gnome.adwaita-icon-theme
-    pkg-config gettext meson ninja python3 vala desktop-file-utils
+    wrapGAppsHook
+    itstool
+    libxml2
+    gnome.adwaita-icon-theme
+    pkg-config
+    gettext
+    meson
+    ninja
+    python3
+    vala
+    desktop-file-utils
   ];
+
   buildInputs = [
     gtk3
   ];
···
     chmod +x build-aux/meson_post_install.py
     patchShebangs build-aux/meson_post_install.py
   '';
+
+  passthru = {
+    updateScript = gnome.updateScript {
+      packageName = "gnome-tetravex";
+      attrPath = "gnome.gnome-tetravex";
+    };
+  };
 
   meta = with lib; {
     homepage = "https://wiki.gnome.org/Apps/Tetravex";

pkgs/desktops/gnome/games/hitori/default.nix

···
-{ lib, stdenv
+{ stdenv
+, lib
 , fetchurl
+, fetchpatch
 , meson
 , ninja
 , pkg-config
···
     url = "mirror://gnome/sources/hitori/${lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
     sha256 = "99cQPLBjP7ATcwExqYw646IWK5+5SZ/H8ZUS1YG/ZWk=";
   };
+
+  patches = [
+    # Fix build with meson 0.61
+    # data/meson.build:3:0: ERROR: Function does not take positional arguments.
+    (fetchpatch {
+      url = "https://gitlab.gnome.org/GNOME/hitori/-/commit/d25728e122f1d7b985029a5ba96810c3e57c27f7.patch";
+      sha256 = "LwBpFFr+vLacLTpto7PwvO1p2lku6epyEv9YZvUvW+g=";
+    })
+  ];
 
   nativeBuildInputs = [
     meson

pkgs/desktops/gnome/misc/gitg/default.nix

···
 { lib
 , stdenv
 , fetchurl
+, fetchpatch
 , vala
 , gettext
 , pkg-config
···
     url = "mirror://gnome/sources/${pname}/${lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
     sha256 = "f7Ybn7EPuqVI0j1wZbq9cq1j5iHeVYQMBlzm45hsRik=";
   };
+
+  patches = [
+    # Fix build with meson 0.61
+    # data/meson.build:8:5: ERROR: Function does not take positional arguments.
+    (fetchpatch {
+      url = "https://gitlab.gnome.org/GNOME/gitg/-/commit/1978973b12848741b08695ec2020bac98584d636.patch";
+      sha256 = "sha256-RzaGPGGiKMgjy0waFqt48rV2yWBGZgC3kHehhVhxktk=";
+    })
+  ];
 
   nativeBuildInputs = [
     gobject-introspection

pkgs/development/compilers/llvm/14/default.nix

···
 
 let
   release_version = "14.0.0";
-  candidate = "rc4"; # empty or "rcN"
+  candidate = ""; # empty or "rcN"
   dash-candidate = lib.optionalString (candidate != "") "-${candidate}";
   rev = ""; # When using a Git commit
   rev-version = ""; # When using a Git commit
···
     owner = "llvm";
     repo = "llvm-project";
     rev = if rev != "" then rev else "llvmorg-${version}";
-    sha256 = "0xm3hscg6xv48rjdi7sg9ky960af1qyg5k3jyavnaqimlaj9wxgp";
+    sha256 = "1ixqzjzq4ad3mv1w44gwcg1shy34c2b3i9ja71vx1wa7l2ms2376";
   };
 
   llvm_meta = {

pkgs/development/compilers/openjdk/8.nix

···
-{ stdenv, lib, fetchurl, pkg-config, lndir, bash, cpio, file, which, unzip, zip
+{ stdenv, lib, fetchFromGitHub, pkg-config, lndir, bash, cpio, file, which, unzip, zip
 , cups, freetype, alsa-lib, cacert, perl, liberation_ttf, fontconfig, zlib
 , libX11, libICE, libXrender, libXext, libXt, libXtst, libXi, libXinerama, libXcursor, libXrandr
 , libjpeg, giflib
···
     aarch64-linux = "aarch64";
   }.${stdenv.system} or (throw "Unsupported platform");
 
-  update = "272";
-  build = if stdenv.isAarch64 then "b10" else "b10";
-  baseurl = if stdenv.isAarch64 then "https://hg.openjdk.java.net/aarch64-port/jdk8u-shenandoah"
-            else "https://hg.openjdk.java.net/jdk8u/jdk8u";
-  repover = lib.optionalString stdenv.isAarch64 "aarch64-shenandoah-"
-            + "jdk8u${update}-${build}";
+  update = "322";
+  build = "ga";
 
-  jdk8 = fetchurl {
-             name = "jdk8-${repover}.tar.gz";
-             url = "${baseurl}/archive/${repover}.tar.gz";
-             sha256 = if stdenv.isAarch64 then "db98897d6fddce85996a9b0daf4352abce4578be0b51eada41702ee1469dd415"
-                      else "8f0e8324d3500432e8ed642b4cc7dff90a617dbb2a18a94c07c1020d32f93b7a";
-          };
-  langtools = fetchurl {
-             name = "langtools-${repover}.tar.gz";
-             url = "${baseurl}/langtools/archive/${repover}.tar.gz";
-             sha256 = if stdenv.isAarch64 then "6544c1cc455844bbbb3d2914ffc716b1cee7f19e6aa223764d41a7cddc41322c"
-                      else "632417b0b067c929eda6958341352e29c5810056a5fec138641eb3503f9635b7";
-          };
-  hotspot = fetchurl {
-             name = "hotspot-${repover}.tar.gz";
-             url = "${baseurl}/hotspot/archive/${repover}.tar.gz";
-             sha256 = if stdenv.isAarch64 then "37abb89e66641607dc6f372946bfc6bd413f23fec0b9c3baf75f41ce517e21d8"
-                      else "2142f3b769800a955613b51ffe192551bab1db95b0c219900cf34febc6f20245";
-          };
-  corba = fetchurl {
-             name = "corba-${repover}.tar.gz";
-             url = "${baseurl}/corba/archive/${repover}.tar.gz";
-             sha256 = if stdenv.isAarch64 then "5da82f7b4aceff32e02d2f559033e3b62b9509d79f1a6891af871502e1d125b1"
-                      else "320098d64c843c1ff2ae62579817f9fb4a81772bc0313a543ce68976ad7a6d98";
-          };
-  jdk = fetchurl {
-             name = "jdk-${repover}.tar.gz";
-             url = "${baseurl}/jdk/archive/${repover}.tar.gz";
-             sha256 = if stdenv.isAarch64 then "ee613296d823605dcd1a0fe2f89b4c7393bdb8ae5f2659f48f5cbc0012bb1a47"
-                      else "957c24fc58ac723c8cd808ab60c77d7853710148944c8b9a59f470c4c809e1a0";
-          };
-  jaxws = fetchurl {
-             name = "jaxws-${repover}.tar.gz";
-             url = "${baseurl}/jaxws/archive/${repover}.tar.gz";
-             sha256 = if stdenv.isAarch64 then "7c426b85f0d378125fa46e6d1b25ddc27ad29d93514d38c5935c84fc540b26ce"
-                      else "4efb0ee143dfe86c8ee06db2429fb81a0c8c65af9ea8fc18daa05148c8a1162f";
-          };
-  jaxp = fetchurl {
-             name = "jaxp-${repover}.tar.gz";
-             url = "${baseurl}/jaxp/archive/${repover}.tar.gz";
-             sha256 = if stdenv.isAarch64 then "928e363877afa7e0ad0c350bb18be6ab056b23708c0624a0bd7f01c4106c2a14"
-                      else "25a651c670d5b036042f7244617a3eb11fec80c07745c1c8181a1cdebeda3d8e";
-          };
-  nashorn = fetchurl {
-             name = "nashorn-${repover}.tar.gz";
-             url = "${baseurl}/nashorn/archive/${repover}.tar.gz";
-             sha256 = if stdenv.isAarch64 then "f060e08c5924457d4f5047c02ad6a987bdbdcd1cea53d2208322073ba4f398c3"
-                      else "a28b41d86f0c87ceacd2b686dd31c9bf391d851b1b5187a49ef5e565fc2cbc84";
-          };
-  openjdk8 = stdenv.mkDerivation {
+  openjdk8 = stdenv.mkDerivation rec {
     pname = "openjdk" + lib.optionalString headless "-headless";
     version = "8u${update}-${build}";
 
-    srcs = [ jdk8 langtools hotspot corba jdk jaxws jaxp nashorn ];
-    sourceRoot = ".";
-
+    src = fetchFromGitHub {
+      owner = "openjdk";
+      repo = "jdk8u";
+      rev = "jdk${version}";
+      sha256 = "sha256-e39Yv+NDQG7z6fGmpKEnkKd5MoHZ50SXlq/Q7lzWcDA=";
+    };
     outputs = [ "out" "jre" ];
 
     nativeBuildInputs = [ pkg-config lndir unzip ];
···
     ] ++ lib.optionals (!headless && enableGnome2) [
       gtk2 gnome_vfs GConf glib
     ];
-
-    # move the seven other source dirs under the main jdk8u directory,
-    # with version suffixes removed, as the remainder of the build will expect
-    prePatch = ''
-      mainDir=$(find . -maxdepth 1 -name jdk8u\*);
-      find . -maxdepth 1 -name \*jdk\* -not -name jdk8u\* | awk -F- '{print $1}' | while read p; do
-        mv $p-* $mainDir/$p
-      done
-      cd $mainDir
-    '';
 
     patches = [
       ./fix-java-home-jdk8.patch

pkgs/development/coq-modules/VST/default.nix

···
   preConfigure = ''
     patchShebangs util
     substituteInPlace Makefile \
+      --replace 'COQVERSION= ' 'COQVERSION= 8.15.1 or-else '\
       --replace 'FLOYD_FILES=' 'FLOYD_FILES= ${toString extra_floyd_files}'
   '';
 

pkgs/development/coq-modules/compcert/default.nix

···
             url = "https://github.com/AbsInt/CompCert/commit/a882f78c069f7337dd9f4abff117d4df98ef38a6.patch";
             sha256 = "sha256:16i87s608fj9ni7cvd5wrd7gicqniad7w78wi26pxdy0pacl7bjg";
           })
+          # Support for Coq 8.15.1
+          (fetchpatch {
+            url = "https://github.com/AbsInt/CompCert/commit/10a976994d7fd30d143354c289ae735d210ccc09.patch";
+            sha256 = "sha256:0bg58gpkgxlmxzp6sg0dvybrfk0pxnm7qd6vxlrbsbm2w6wk03jv";
+          })
         ];
       }
     ] [];

pkgs/development/libraries/bctoolbox/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "bctoolbox";
-  version = "5.1.10";
+  version = "5.1.12";
 
   nativeBuildInputs = [ cmake bcunit ];
   buildInputs = [ mbedtls ];
···
     group = "BC";
     repo = pname;
     rev = version;
-    sha256 = "sha256-BOJ/NUJnoTeDuURH8Lx6S4RlNZPfsQX4blJkpUdraBg=";
+    sha256 = "sha256-tmZ1XC8z4NUww58pvvqxZifOxFNXSrEBMY2biCJ55XM=";
   };
 
   # Do not build static libraries

pkgs/development/libraries/gcr/default.nix

···
 { lib, stdenv
 , fetchurl
+, fetchpatch
 , pkg-config
 , meson
 , ninja
···
     url = "mirror://gnome/sources/${pname}/${lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
     sha256 = "CQn8SeqK1IMtJ1ZP8v0dxmZpbioHxzlBxIgp5gVy2gE=";
   };
+
+  patches = [
+    # Pull upstream fix for meson-0.60:
+    #  https://gitlab.gnome.org/GNOME/gcr/-/merge_requests/81
+    (fetchpatch {
+      name = "meson-0.60.patch";
+      url = "https://gitlab.gnome.org/GNOME/gcr/-/commit/b3ca1d02bb0148ca787ac4aead164d7c8ce2c4d8.patch";
+      sha256 = "15gwxkcm5q5p87p5lrqwgykpzx5gmk179xd3481yak93yhbvy165";
+    })
+  ];
 
   nativeBuildInputs = [
     pkg-config

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

···
 {
-  mkDerivation, propagate,
-  extra-cmake-modules, kcoreaddons, polkit-qt, qttools
+  lib, mkDerivation, propagate,
+  extra-cmake-modules, kcoreaddons, qttools,
+  enablePolkit ? true, polkit-qt
 }:
 
 mkDerivation {
   name = "kauth";
   nativeBuildInputs = [ extra-cmake-modules ];
-  buildInputs = [ polkit-qt qttools ];
+  buildInputs = lib.optional enablePolkit polkit-qt ++ [ qttools ];
   propagatedBuildInputs = [ kcoreaddons ];
   patches = [
     ./cmake-install-paths.patch

pkgs/development/libraries/libgpg-error/default.nix

···
   '' + lib.optionalString (stdenv.hostPlatform.isAarch32 && stdenv.hostPlatform.isMusl) ''
     ln -s lock-obj-pub.arm-unknown-linux-gnueabi.h src/syscfg/lock-obj-pub.arm-unknown-linux-musleabihf.h
     ln -s lock-obj-pub.arm-unknown-linux-gnueabi.h src/syscfg/lock-obj-pub.linux-musleabihf.h
+  '' + lib.optionalString (stdenv.hostPlatform.isAarch64 && stdenv.hostPlatform.isMusl) ''
+    ln -s lock-obj-pub.aarch64-unknown-linux-gnu.h src/syscfg/lock-obj-pub.linux-musl.h
   '';
 
   outputs = [ "out" "dev" "info" ];

pkgs/development/libraries/libqb/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "libqb";
-  version = "2.0.5";
+  version = "2.0.6";
 
   src = fetchFromGitHub {
     owner = "ClusterLabs";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-G49JBEUkO4ySAamvI7xN6ct1SvN4afcOmdrzpDL90FE=";
+    sha256 = "sha256-vt9FmIRojX3INOn3CXAjkswVFD8Th4sRIz3RR4GJHFQ=";
   };
 
   nativeBuildInputs = [ autoreconfHook pkg-config ];

pkgs/development/ocaml-modules/biniou/1.0.nix

···
   makeFlags = [ "PREFIX=$(out)" ];
 
   preBuild = ''
-    mkdir $out/bin
+    mkdir -p $out/bin
   '';
 
   meta = with lib; {

pkgs/development/ocaml-modules/csv/1.5.nix

···
   doCheck = true;
   checkPhase = "ocaml setup.ml -test";
 
-  installPhase = "ocaml setup.ml -install";
+  installPhase = ''
+    runHook preInstall
+    ocaml setup.ml -install
+    runHook postInstall
+  '';
 
   meta = with lib; {
     description = "A pure OCaml library to read and write CSV files";
     homepage = "https://github.com/Chris00/ocaml-csv";
     license = licenses.lgpl21;
     maintainers = [ maintainers.vbgl ];
-    platforms = ocaml.meta.platforms or [ ];
+    inherit (ocaml.meta) platforms;
   };
 }

pkgs/development/ocaml-modules/magick/default.nix

···
-{ stdenv, lib, fetchurl, which, pkg-config, ocaml, findlib, imagemagick }:
-
-if lib.versionAtLeast ocaml.version "4.06"
-then throw "magick is not available for OCaml ${ocaml.version}"
-else
-
-stdenv.mkDerivation rec {
-  pname = "ocaml-magick";
-  version = "0.34";
-
-  src = fetchurl {
-    url = "http://www.linux-nantes.org/~fmonnier/OCaml/ImageMagick/ImageMagick/OCaml-ImageMagick-${version}.tgz";
-    sha256 = "0gn9l2qdr8gby2x8c2mb59x1kipb2plr45rbq6ymcxyi0wmzfh3q";
-  };
-
-  nativeBuildInputs = [ which pkg-config ocaml findlib ];
-  buildInputs = [ imagemagick ];
-
-  strictDeps = true;
-
-  createFindlibDestdir = true;
-
-  preConfigure = "substituteInPlace Makefile --replace gcc $CC";
-
-  installTargets = [ "find_install" ];
-
-  meta = {
-    homepage = "http://www.linux-nantes.org/~fmonnier/OCaml/ImageMagick/";
-    description = "ImageMagick Binding for OCaml";
-    license = lib.licenses.mit;
-    platforms = imagemagick.meta.platforms;
-    maintainers = with lib.maintainers; [ vbgl ];
-  };
-}

pkgs/development/ocaml-modules/ocaml-libvirt/default.nix

···
 { lib, stdenv, fetchFromGitLab, libvirt, autoreconfHook, pkg-config, ocaml, findlib, perl }:
 
+lib.throwIfNot (lib.versionAtLeast ocaml.version "4.02")
+  "libvirt is not available for OCaml ${ocaml.version}"
+
 stdenv.mkDerivation rec {
   pname = "ocaml-libvirt";
   version = "0.6.1.5";

pkgs/development/python-modules/ansible-runner/default.nix

···
 
 buildPythonPackage rec {
   pname = "ansible-runner";
-  version = "2.1.2";
+  version = "2.1.3";
   format = "setuptools";
 
   src = fetchPypi {
     inherit pname version;
-    hash = "sha256-GK/CqmMm67VmvzlhMV6ow+40m0DYUpXCFkP+9NgR/e4=";
+    hash = "sha256-2m5dD+gGDL5LnY7QbDYiGdu4GYu0C49WU29GZY2bnBo=";
   };
 
   propagatedBuildInputs = [

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

···
 
 buildPythonPackage rec {
   pname = "auth0-python";
-  version = "3.20.0";
+  version = "3.22.0";
   format = "setuptools";
 
   disabled = pythonOlder "3.7";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "sha256-WIH2lMPehrqkXCh+JbEI5nf99nt61OwLhP/pF6BbsnQ=";
+    sha256 = "sha256-05yJbF6eXz+vJx+plY5gqzRRYL2SjDnF7gSfX6WIS4E=";
   };
 
   propagatedBuildInputs = [

pkgs/development/python-modules/azure-mgmt-applicationinsights/default.nix

···
 
 buildPythonPackage rec {
   pname = "azure-mgmt-applicationinsights";
-  version = "2.1.0";
+  version = "3.0.0";
 
   src = fetchPypi {
     inherit pname version;
     extension = "zip";
-    sha256 = "68deed8ee884dd0b9631804e8b9c65fcd94e8e01c7218beae96a9fe557d7a0d7";
+    sha256 = "sha256-K46J0WqQt4vwr1CE4yjxKUT/Atds5BLs0k8EjOA4yzA=";
   };
 
   propagatedBuildInputs = [

pkgs/development/python-modules/azure-mgmt-resource/default.nix

···
 
 
 buildPythonPackage rec {
-  version = "20.1.0";
+  version = "21.0.0";
   pname = "azure-mgmt-resource";
   disabled = !isPy3k;
 
   src = fetchPypi {
     inherit pname version;
     extension = "zip";
-    sha256 = "4fbb2158320e0bdd367882642f266a6dfb3b4b8610792b3afbbca39089f212d7";
+    sha256 = "sha256-y9J/UhxwtA/YO/Y88XsStbwD5ecNwrbnpxtevYuQDQM=";
   };
 
   propagatedBuildInputs = [

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

···
 
 buildPythonPackage rec {
   pname = "bidict";
-  version = "0.21.4";
+  version = "0.22.0";
 
   disabled = pythonOlder "3.7";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "sha256-QshP++b43omK9gc7S+nqfM7c1400dKqETFTknVoHn28=";
+    sha256 = "sha256-XIJrPhXpfMbmFd4pV1aEfCgqebecVDDTv8kJsayfW9g=";
   };
 
   propagatedBuildInputs = [

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

···
 
 buildPythonPackage rec {
   pname = "blis";
-  version = "0.7.6";
+  version = "0.7.7";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "sha256-/pexD2ihx7VMDlS+rahOGPTvto3UDJBvuHSPURR0PsY=";
+    sha256 = "sha256-XUqB+UONt6GayOZK1BMx9lplnqjzuxiJqcIIjP2f4QQ=";
   };
 
   nativeBuildInputs = [

pkgs/development/python-modules/coqui-trainer/default.nix

···
 { lib
 , buildPythonPackage
+, fetchpatch
 , fetchFromGitHub
+, pythonAtLeast
 
 , coqpit
 , fsspec
-, pytorch
+, pytorch-bin
 
 , pytestCheckHook
 , soundfile
-, tensorboardx
-, torchvision
+, torchvision-bin
 }:
 
 let
···
 buildPythonPackage {
   inherit pname version;
   format = "pyproject";
+
+  disabled = pythonAtLeast "3.10"; # https://github.com/coqui-ai/Trainer/issues/22
 
   src = fetchFromGitHub {
     owner = "coqui-ai";
···
     hash = "sha256-NsgCh+N2qWmRkTOjXqisVCP5aInH2zcNz6lsnIfVLiY=";
   };
 
+  patches = [
+    (fetchpatch {
+      url = "https://github.com/coqui-ai/Trainer/commit/07b447abf3290c8f2e5e723687b8a480b7382265.patch";
+      sha256 = "0v1hl784d9rghkblcfwgzp0gg9d6r5r0yv2kapzdz2qymiajy7y2";
+    })
+  ];
+
   propagatedBuildInputs = [
     coqpit
     fsspec
-    pytorch
+    pytorch-bin
     soundfile
-    tensorboardx
   ];
 
   # only one test and that requires training data from the internet
···
 
   checkInputs = [
     pytestCheckHook
-    torchvision
+    torchvision-bin
   ];
 
   pythonImportsCheck = [

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

···
 
 buildPythonPackage rec {
   pname = "datasette";
-  version = "0.60.2";
+  version = "0.61.1";
 
   disabled = pythonOlder "3.6";
 
···
     owner = "simonw";
     repo = pname;
     rev = version;
-    sha256 = "sha256-GehtjukmSVHffAnDeDwjopgnuycD1CLQRHzLtO1iLsE=";
+    sha256 = "sha256-HVzMyF4ujYK12UQ25il/XROPo+iBldsMxOTx+duoc5o=";
   };
 
   propagatedBuildInputs = [

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

···
 
 buildPythonPackage rec {
   pname = "evdev";
-  version = "1.4.0";
+  version = "1.5.0";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "8782740eb1a86b187334c07feb5127d3faa0b236e113206dfe3ae8f77fb1aaf1";
+    sha256 = "sha256-WzOxdPfIRXbn3WBx5Di/WtIn2pXv1DVqOf5Mg1VBL+Y=";
   };
 
   buildInputs = [ linuxHeaders ];

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

···
 , async_generator
 , buildPythonPackage
 , fetchPypi
-, fetchpatch
 , hypothesis
 , lupa
 , pytest-asyncio
···
 
 buildPythonPackage rec {
   pname = "fakeredis";
-  version = "1.7.0";
-
+  version = "1.7.1";
   format = "pyproject";
 
   disabled = pythonOlder "3.7";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "sha256-yb0S5DAzbL0+GJ+uDpHrmZl7k+dtv91u1n+jUtxoTHE=";
+    hash = "sha256-fCxLobQuCnUzfFS3d78GcQVrRWllDj/5J+S5s4WvyOw=";
   };
 
-  patches = [
-    (fetchpatch {
-      # redis 4.1.0 compatibility
-      # https://github.com/jamesls/fakeredis/pull/324
-      url = "https://github.com/jamesls/fakeredis/commit/8ef8dc6dacc9baf571d66a25ffbf0fadd7c70f78.patch";
-      sha256 = "sha256:03xlqmwq8nkzisrjk7y51j2jd6qdin8nbj5n9hc4wjabbvlgx4qr";
-      excludes = [
-        "setup.cfg"
-      ];
-    })
-  ];
-
   propagatedBuildInputs = [
     aioredis
     lupa
···
   pythonImportsCheck = [
     "fakeredis"
   ];
-
-  postPatch = ''
-    substituteInPlace setup.cfg \
-      --replace "redis<4.1.0" "redis"
-  '';
 
   meta = with lib; {
     description = "Fake implementation of Redis API";

pkgs/development/python-modules/flake8-bugbear/default.nix

···
 
 buildPythonPackage rec {
   pname = "flake8-bugbear";
-  version = "22.3.20";
+  version = "22.3.23";
 
   src = fetchFromGitHub {
     owner = "PyCQA";
     repo = pname;
     rev = version;
-    sha256 = "sha256-tq008SNytZCttnVY1NLf9/2aeqP+iPLUNsRLZu0k3Uk=";
+    sha256 = "sha256-s1EnPM2He+R+vafu14XI1Xuft8Rg6W3vPH2Atc6N7I0=";
   };
 
   propagatedBuildInputs = [

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

···
 
 buildPythonPackage rec {
   pname = "gaphas";
-  version = "3.5.1";
+  version = "3.6.0";
   disabled = pythonOlder "3.7";
 
   format = "pyproject";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "sha256-71oYuLhqJ7bst0W7v9tQSoaisjONZSa9zEWzYWtGl2E=";
+    sha256 = "sha256-yleYbAJdDVzZrMQ3izi9UX3Ji1vIuQDc+RK5+wzrMi4=";
   };
 
   nativeBuildInputs = [

pkgs/development/python-modules/google-cloud-container/default.nix

···
 , proto-plus
 , pytestCheckHook
 , pytest-asyncio
+, pythonOlder
 }:
 
 buildPythonPackage rec {
   pname = "google-cloud-container";
-  version = "2.10.6";
+  version = "2.10.7";
+  format = "setuptools";
+
+  disabled = pythonOlder "3.7";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "sha256-dBt2Vs9J0+l534YtKS70MuUEUegwVoU66zghmcz7fGk=";
+    hash = "sha256-I3oYldj915GBCX5VLEZRqGS7jMHWasQGVIvj50EUTK4=";
   };
 
-  propagatedBuildInputs = [ google-api-core grpc-google-iam-v1 libcst proto-plus ];
+  propagatedBuildInputs = [
+    google-api-core
+    grpc-google-iam-v1
+    libcst
+    proto-plus
+  ];
 
-  checkInputs = [ mock pytestCheckHook pytest-asyncio ];
+  checkInputs = [
+    mock
+    pytestCheckHook
+    pytest-asyncio
+  ];
 
   disabledTests = [
     # requires credentials

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

···
 
 buildPythonPackage rec {
   pname = "hahomematic";
-  version = "0.38.4";
+  version = "0.38.5";
   format = "setuptools";
 
   disabled = pythonOlder "3.9";
···
     owner = "danielperna84";
     repo = pname;
     rev = version;
-    sha256 = "sha256-WvcQTaYlKTOYbYwH/FbNTMoHdUhesYeeNYP8RDgQms4=";
+    sha256 = "sha256-RzTRRWHmdEjDQM/x4pX1gy7mIJD3K2hjQRAkz53xL50=";
   };
 
   propagatedBuildInputs = [

pkgs/development/python-modules/mkdocs-material/default.nix

···
 
 buildPythonApplication rec {
   pname = "mkdocs-material";
-  version = "8.2.5";
+  version = "8.2.6";
 
   src = fetchFromGitHub {
     owner = "squidfunk";
     repo = pname;
     rev = version;
-    sha256 = "0v30x2cgc5i307p0hsy5h58pfd8w6xpnvimsb75614xlmx3ycaqd";
+    sha256 = "sha256-4t9LBZc73V8eAIUO+BAZPgak+AX3o2YKZJWug+b6TBY=";
   };
 
   propagatedBuildInputs = [

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

···
 
 buildPythonPackage rec {
   pname = "motionblinds";
-  version = "0.6.1";
+  version = "0.6.3";
   format = "setuptools";
 
   disabled = pythonOlder "3.7";
···
     owner = "starkillerOG";
     repo = "motion-blinds";
     rev = version;
-    sha256 = "sha256-31ofLiBQjSMDtptgYF5rqS1bB5UDUbsbo25Nrk4WvIY=";
+    sha256 = "sha256-Y5yF/dJUm0ICUY8UU8ILypSAnCVanvW4hzyz7ZOdBrc=";
   };
 
   propagatedBuildInputs = [

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

···
-{ lib, buildPythonPackage, fetchPypi, crcmod }:
+{ lib
+, buildPythonPackage
+, fetchFromGitHub
+, crcmod
+, pytestCheckHook
+, pythonOlder
+}:
 
 buildPythonPackage rec {
   pname = "ndspy";
-  version = "3.0.0";
+  version = "4.0.0";
+  format = "setuptools";
 
-  src = fetchPypi {
-    inherit pname version;
-    sha256 = "1s0i81gspas22bjwk9vhy3x5sw1svyybk7c2j1ixc77drr9ym20a";
+  disabled = pythonOlder "3.6";
+
+  src = fetchFromGitHub {
+    owner = "RoadrunnerWMC";
+    repo = pname;
+    rev = "v${version}";
+    sha256 = "0x3sp10had1mq192m7kgjivvs8kpjagxjgj9d4z95dfjhzzbjh70";
   };
 
-  propagatedBuildInputs = [ crcmod ];
+  propagatedBuildInputs = [
+    crcmod
+  ];
 
-  doCheck = false; # there are no tests
-  pythonImportsCheck = [ "ndspy" ];
+  checkInputs = [
+    pytestCheckHook
+  ];
+
+  pythonImportsCheck = [
+    "ndspy"
+  ];
+
+  preCheck = ''
+    cd tests
+  '';
 
   meta = with lib; {
+    description = "Python library for many Nintendo DS file formats";
     homepage = "https://github.com/RoadrunnerWMC/ndspy";
-    description = "A Python library for many Nintendo DS file formats";
     license = licenses.gpl3Plus;
     maintainers = with maintainers; [ xfix ];
   };

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

···
 
 buildPythonPackage rec {
   pname = "pulsectl";
-  version = "22.1.3";
+  version = "22.3.2";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "sha256-8o/kuIHdLMFE0tlPg+xg2MWaUmQqCtNjXMTQ+EBvSFg=";
+    sha256 = "sha256-zBdOHO69TmIixbePT0FfEugHU8mrdas1QVm0y1lQsIQ=";
   };
 
   patches = [

pkgs/development/python-modules/py-synologydsm-api/default.nix

···
 
 buildPythonPackage rec {
   pname = "py-synologydsm-api";
-  version = "1.0.6";
+  version = "1.0.7";
   format = "pyproject";
 
   src = fetchFromGitHub {
     owner = "mib1185";
     repo = "synologydsm-api";
     rev = "v${version}";
-    sha256 = "sha256-jAdD6FCbsBocJNX7o+dpthgHaPLIueFWJMzBNoKAq7w=";
+    sha256 = "sha256-VhAzR/knvun6hJj8/YREqMfNvOKpTyYNI9fk9hsbHDQ=";
   };
 
   nativeBuildInputs = [

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

···
 
 buildPythonPackage rec {
   pname = "pyaussiebb";
-  version = "0.0.14";
+  version = "0.0.15";
   format = "pyproject";
 
   disabled = pythonOlder "3.9";
···
     owner = "yaleman";
     repo = "aussiebb";
     rev = "v${version}";
-    hash = "sha256-Z+xLCKnUnBAH9nm0YR11zx1lyNrIb8BZLFmaZdpnfdw=";
+    hash = "sha256-V9yN05Bkv5vkHgXZ77ps3d6JS39M5iMuiijOGRBFi0U=";
   };
 
   nativeBuildInputs = [

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

···
       buildinputs_include = builtins.toJSON (builtins.concatMap (dep: [
         "${lib.getDev dep}/"
         "${lib.getDev dep}/include"
+        "${lib.getDev dep}/include/SDL2"
       ]) buildInputs);
       buildinputs_lib = builtins.toJSON (builtins.concatMap (dep: [
         "${lib.getLib dep}/"

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

···
 
 buildPythonPackage rec {
   pname = "pypandoc";
-  version = "1.7.3";
+  version = "1.7.4";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "sha256-Tv0vqKN9AAXdfQRMt/QuqeFB3wNTh1DsWu0XNZukTUc=";
+    sha256 = "sha256-KN4j9kbZ6ARAPGth180yptdso1arx563IXvb/2dI+G4=";
   };
 
   patches = [

pkgs/development/python-modules/pysigma-backend-splunk/default.nix

···
 
 buildPythonPackage rec {
   pname = "pysigma-backend-splunk";
-  version = "0.2.0";
+  version = "0.2.2";
   format = "pyproject";
 
   disabled = pythonOlder "3.8";
···
     owner = "SigmaHQ";
     repo = "pySigma-backend-splunk";
     rev = "v${version}";
-    hash = "sha256-EP0gcK05hZ5TCOgTePezfEGbW45dGrnnksWyI9Jo9MQ=";
+    hash = "sha256-NAhAWK1eSSGQAlMGgMHrW/RTpT9LJMqwkhE9/8xWGT8=";
   };
 
   nativeBuildInputs = [

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

···
 
 buildPythonPackage rec {
   pname = "pysigma";
-  version = "0.4.2";
+  version = "0.4.3";
   format = "pyproject";
 
   disabled = pythonOlder "3.8";
···
     owner = "SigmaHQ";
     repo = "pySigma";
     rev = "v${version}";
-    hash = "sha256-0k6m86RQoP4QTuxmCWBpxiGqaJt3alOLS5BAuOFwdb4=";
+    hash = "sha256-NE6XmylUc3MeDRMOJo51jtb6J0Vi9tDT6tbYBepDsvw=";
   };
 
   nativeBuildInputs = [

pkgs/development/python-modules/pytorch/bin.nix

···
 , isPy37
 , isPy38
 , isPy39
+, isPy310
 , python
 , addOpenGLRunpath
 , future
···
   pyVerNoDot = builtins.replaceStrings [ "." ] [ "" ] python.pythonVersion;
   srcs = import ./binary-hashes.nix version;
   unsupported = throw "Unsupported system";
-  version = "1.10.0";
+  version = "1.11.0";
 in buildPythonPackage {
   inherit version;
 
···
 
   format = "wheel";
 
-  disabled = !(isPy37 || isPy38 || isPy39);
+  disabled = !(isPy37 || isPy38 || isPy39 || isPy310);
 
   src = fetchurl srcs."${stdenv.system}-${pyVerNoDot}" or unsupported;
 

pkgs/development/python-modules/pytorch/binary-hashes.nix

···
 # To add a new version, run "prefetch.sh 'new-version'" to paste the generated file as follows.
 
 version : builtins.getAttr version {
-  "1.10.0" = {
+  "1.11.0" = {
     x86_64-linux-37 = {
-      name = "torch-1.10.0-cp37-cp37m-linux_x86_64.whl";
-      url = "https://download.pytorch.org/whl/cu113/torch-1.10.0%2Bcu113-cp37-cp37m-linux_x86_64.whl";
-      hash = "sha256-KpDbklee2HXSqgrWr1U1nj8EJqUjBWp7SbACw8xtKtg=";
+      name = "torch-1.11.0-cp37-cp37m-linux_x86_64.whl";
+      url = "https://download.pytorch.org/whl/cu113/torch-1.11.0%2Bcu113-cp37-cp37m-linux_x86_64.whl";
+      hash = "sha256-9WMzRw2uo8lweLN2B+ADXMz3L8XDb9hFRuGkuNmUTys=";
     };
     x86_64-linux-38 = {
-      name = "torch-1.10.0-cp38-cp38-linux_x86_64.whl";
-      url = "https://download.pytorch.org/whl/cu113/torch-1.10.0%2Bcu113-cp38-cp38-linux_x86_64.whl";
-      hash = "sha256-zM3cMriUG9A+3in/ChzOLytRETpe4ju4uXkxasIRQYM=";
+      name = "torch-1.11.0-cp38-cp38-linux_x86_64.whl";
+      url = "https://download.pytorch.org/whl/cu113/torch-1.11.0%2Bcu113-cp38-cp38-linux_x86_64.whl";
+      hash = "sha256-tqeZvbbuPZFOXmK920J21KECSMGvTy0hdzjl+e4nSFs=";
     };
     x86_64-linux-39 = {
-      name = "torch-1.10.0-cp39-cp39-linux_x86_64.whl";
-      url = "https://download.pytorch.org/whl/cu113/torch-1.10.0%2Bcu113-cp39-cp39-linux_x86_64.whl";
-      hash = "sha256-w8UJDh4b5cgDu7ZSvDoKzNH4hiXEyRfvpycNOg+wJOg=";
+      name = "torch-1.11.0-cp39-cp39-linux_x86_64.whl";
+      url = "https://download.pytorch.org/whl/cu113/torch-1.11.0%2Bcu113-cp39-cp39-linux_x86_64.whl";
+      hash = "sha256-6RJrCl2VcEvuQKnQ7xy9gtjceGPkY4o3a+9wLf1lk3A=";
+    };
+    x86_64-linux-310 = {
+      name = "torch-1.11.0-cp310-cp310-linux_x86_64.whl";
+      url = "https://download.pytorch.org/whl/cu113/torch-1.11.0%2Bcu113-cp310-cp310-linux_x86_64.whl";
+      hash = "sha256-powzZXpUYTHrm8ROKpjS+nBKr66GFGCwUbgoE4Usy0Q=";
     };
     x86_64-darwin-37 = {
-      name = "torch-1.10.0-cp37-none-macosx_10_9_x86_64.whl";
-      url = "https://download.pytorch.org/whl/cpu/torch-1.10.0-cp37-none-macosx_10_9_x86_64.whl";
-      hash = "sha256-RJkFVUcIfX736KdU8JwsTxRwKXrj5UkDY9umbHVQGyE=";
+      name = "torch-1.11.0-cp37-none-macosx_10_9_x86_64.whl";
+      url = "https://download.pytorch.org/whl/cpu/torch-1.11.0-cp37-none-macosx_10_9_x86_64.whl";
+      hash = "sha256-aGCx0b8LsLZ6a9R/haDkyCW1GO6hO11hAZmdu8vVvAw=";
     };
     x86_64-darwin-38 = {
-      name = "torch-1.10.0-cp38-none-macosx_10_9_x86_64.whl";
-      url = "https://download.pytorch.org/whl/cpu/torch-1.10.0-cp38-none-macosx_10_9_x86_64.whl";
-      hash = "sha256-rvevti6bF0tODl4eSkLjurO4SQpmjWZvYvfUUXVZ+/I=";
+      name = "torch-1.11.0-cp38-none-macosx_10_9_x86_64.whl";
+      url = "https://download.pytorch.org/whl/cpu/torch-1.11.0-cp38-none-macosx_10_9_x86_64.whl";
+      hash = "sha256-DMyFzQYiej7fgJ4seV/Vdiw9Too4tcn3RMbnz4QTYbs=";
     };
     x86_64-darwin-39 = {
-      name = "torch-1.10.0-cp39-none-macosx_10_9_x86_64.whl";
-      url = "https://download.pytorch.org/whl/cpu/torch-1.10.0-cp39-none-macosx_10_9_x86_64.whl";
-      hash = "sha256-1u+HRwtE35lw6EVCVH1bp3ILuJYWYCRB31VaObEk4rw=";
+      name = "torch-1.11.0-cp39-none-macosx_10_9_x86_64.whl";
+      url = "https://download.pytorch.org/whl/cpu/torch-1.11.0-cp39-none-macosx_10_9_x86_64.whl";
+      hash = "sha256-UP2b+FxXjIccKPHLCs6d/GAkQBx/OZsXT7DzcImfRFQ=";
+    };
+    x86_64-darwin-310 = {
+      name = "torch-1.11.0-cp310-none-macosx_10_9_x86_64.whl";
+      url = "https://download.pytorch.org/whl/cpu/torch-1.11.0-cp39-none-macosx_10_9_x86_64.whl";
+      hash = "sha256-UP2b+FxXjIccKPHLCs6d/GAkQBx/OZsXT7DzcImfRFQ=";
     };
     aarch64-darwin-38 = {
-      name = "torch-1.10.0-cp38-none-macosx_11_0_arm64.whl";
-      url = "https://download.pytorch.org/whl/cpu/torch-1.10.0-cp38-none-macosx_11_0_arm64.whl";
-      hash = "sha256-1hhYJ7KFeAZTzdgdd6Cf3KdqWxkNWYbVUr4qXEQs+qQ=";
+      name = "torch-1.11.0-cp38-none-macosx_11_0_arm64.whl";
+      url = "https://download.pytorch.org/whl/cpu/torch-1.11.0-cp38-none-macosx_11_0_arm64.whl";
+      hash = "sha256-wVVOSddPGyw+cgLXcFa6LddGVDdYW6xkBitYD3FKROk=";
     };
     aarch64-darwin-39 = {
-      name = "torch-1.10.0-cp39-none-macosx_11_0_arm64.whl";
-      url = "https://download.pytorch.org/whl/cpu/torch-1.10.0-cp39-none-macosx_11_0_arm64.whl";
-      hash = "sha256-7qZ17AHsS0oGVf0phPFmpco7kz2uatTrTlLrpwJtwXY=";
+      name = "torch-1.11.0-cp39-none-macosx_11_0_arm64.whl";
+      url = "https://download.pytorch.org/whl/cpu/torch-1.11.0-cp39-none-macosx_11_0_arm64.whl";
+      hash = "sha256-DkivZq11Xw+cXyZkAopBT1fEnWrcN+d+Bv4ABNpO22E=";
+    };
+    aarch64-darwin-310 = {
+      name = "torch-1.11.0-cp310-none-macosx_11_0_arm64.whl";
+      url = "https://download.pytorch.org/whl/cpu/torch-1.11.0-cp39-none-macosx_11_0_arm64.whl";
+      hash = "sha256-DkivZq11Xw+cXyZkAopBT1fEnWrcN+d+Bv4ABNpO22E=";
     };
   };
 }

pkgs/development/python-modules/pytorch/prefetch.sh

···
 
 version=$1
 
-bucket="https://download.pytorch.org/whl/cu113"
+linux_bucket="https://download.pytorch.org/whl/cu113"
+darwin_bucket="https://download.pytorch.org/whl/cpu"
 
 url_and_key_list=(
-  "x86_64-linux-37 $bucket/torch-${version}%2Bcu113-cp37-cp37m-linux_x86_64.whl torch-${version}-cp37-cp37m-linux_x86_64.whl"
-  "x86_64-linux-38 $bucket/torch-${version}%2Bcu113-cp38-cp38-linux_x86_64.whl torch-${version}-cp38-cp38-linux_x86_64.whl"
-  "x86_64-linux-39 $bucket/torch-${version}%2Bcu113-cp39-cp39-linux_x86_64.whl torch-${version}-cp39-cp39-linux_x86_64.whl"
+  "x86_64-linux-37 $linux_bucket/torch-${version}%2Bcu113-cp37-cp37m-linux_x86_64.whl torch-${version}-cp37-cp37m-linux_x86_64.whl"
+  "x86_64-linux-38 $linux_bucket/torch-${version}%2Bcu113-cp38-cp38-linux_x86_64.whl torch-${version}-cp38-cp38-linux_x86_64.whl"
+  "x86_64-linux-39 $linux_bucket/torch-${version}%2Bcu113-cp39-cp39-linux_x86_64.whl torch-${version}-cp39-cp39-linux_x86_64.whl"
+  "x86_64-linux-310 $linux_bucket/torch-${version}%2Bcu113-cp310-cp310-linux_x86_64.whl torch-${version}-cp310-cp310-linux_x86_64.whl"
+  "x86_64-darwin-37 $darwin_bucket/torch-${version}-cp37-none-macosx_10_9_x86_64.whl torch-${version}-cp37-none-macosx_10_9_x86_64.whl"
+  "x86_64-darwin-38 $darwin_bucket/torch-${version}-cp38-none-macosx_10_9_x86_64.whl torch-${version}-cp38-none-macosx_10_9_x86_64.whl"
+  "x86_64-darwin-39 $darwin_bucket/torch-${version}-cp39-none-macosx_10_9_x86_64.whl torch-${version}-cp39-none-macosx_10_9_x86_64.whl"
+  "x86_64-darwin-310 $darwin_bucket/torch-${version}-cp310-none-macosx_10_9_x86_64.whl torch-${version}-cp310-none-macosx_10_9_x86_64.whl"
+  "aarch64-darwin-38 $darwin_bucket/torch-${version}-cp38-none-macosx_11_0_arm64.whl torch-${version}-cp38-none-macosx_11_0_arm64.whl"
+  "aarch64-darwin-39 $darwin_bucket/torch-${version}-cp39-none-macosx_11_0_arm64.whl torch-${version}-cp39-none-macosx_11_0_arm64.whl"
+  "aarch64-darwin-310 $darwin_bucket/torch-${version}-cp310-none-macosx_11_0_arm64.whl torch-${version}-cp310-none-macosx_11_0_arm64.whl"
 )
 
 hashfile="binary-hashes-$version.nix"

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

···
 { lib, fetchPypi, buildPythonPackage
-, six, systemd, pytest, mock, hypothesis, docutils
+, six, udev, pytest, mock, hypothesis, docutils
 }:
 
 buildPythonPackage rec {
···
 
   postPatch = ''
     substituteInPlace src/pyudev/_ctypeslib/utils.py \
-      --replace "find_library(name)" "'${lib.getLib systemd}/lib/libudev.so'"
+      --replace "find_library(name)" "'${lib.getLib udev}/lib/libudev.so'"
     '';
 
   checkInputs = [ pytest mock hypothesis docutils ];

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

···
 
 buildPythonPackage rec {
   pname = "samsungtvws";
-  version = "2.4.0";
+  version = "2.5.0";
   disabled = isPy27;
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "sha256-LbNHaSbNCwoffox6B8kEUzxjkSJotB+P1bw3wbU7DZk=";
+    sha256 = "sha256-AFCN1b80GZ24g3oWe1qqc72yWQy4+/sorL8zwOYM7vo=";
   };
 
   propagatedBuildInputs = [

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

···
 
 buildPythonPackage rec {
   pname = "stripe";
-  version = "2.67.0";
+  version = "2.68.0";
   format = "setuptools";
 
   disabled = pythonOlder "3.7";
 
   src = fetchPypi {
     inherit pname version;
-    hash = "sha256-cYuT1qGBBSQ7zgybSOUY9y8fCD0n8H4HuL2zpUH+ODU=";
+    hash = "sha256-X3lYAxM/KlC4NjBJrq/4Gze37wpcVKTA11VaQRpAt68=";
   };
 
   propagatedBuildInputs = [

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

···
 
 buildPythonPackage rec {
   pname = "teslajsonpy";
-  version = "1.8.0";
+  version = "1.9.0";
   format = "pyproject";
 
   disabled = pythonOlder "3.6";
···
     owner = "zabuldon";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-9EFbsJPn543fVGQ46cikEE9rE4qBr/2q6vX7u4tui7I=";
+    sha256 = "sha256-Q/ltNdr2Huvfj1RmKFopJbaR4FSM7ziWadmDKPS26vc=";
   };
 
   nativeBuildInputs = [

pkgs/development/python-modules/torchaudio/bin.nix

···
 , stdenv
 , buildPythonPackage
 , fetchurl
+, isPy37
+, isPy38
+, isPy39
+, isPy310
 , python
 , pytorch-bin
 , pythonOlder
···
 
 buildPythonPackage rec {
   pname = "torchaudio";
-  version = "0.10.0";
+  version = "0.11.0";
   format = "wheel";
 
   src =
···
         srcs = (import ./binary-hashes.nix version)."${stdenv.system}-${pyVerNoDot}" or unsupported;
     in fetchurl srcs;
 
-  disabled = ! (pythonAtLeast "3.7" && pythonOlder "3.10");
+  disabled = !(isPy37 || isPy38 || isPy39 || isPy310);
 
   propagatedBuildInputs = [
     pytorch-bin

pkgs/development/python-modules/torchaudio/binary-hashes.nix

···
 # To add a new version, run "prefetch.sh 'new-version'" to paste the generated file as follows.
 
 version : builtins.getAttr version {
-  "0.10.0" = {
+  "0.11.0" = {
     x86_64-linux-37 = {
-      name = "torchaudio-0.10.0-cp37-cp37m-linux_x86_64.whl";
-      url = "https://download.pytorch.org/whl/cu113/torchaudio-0.10.0%2Bcu113-cp37-cp37m-linux_x86_64.whl";
-      hash = "sha256-FspXTTODdkO0nPUJcJm8+vLIvckUa8gRfBPBT9LcKPw=";
+      name = "torchaudio-0.11.0-cp37-cp37m-linux_x86_64.whl";
+      url = "https://download.pytorch.org/whl/cu113/torchaudio-0.11.0%2Bcu113-cp37-cp37m-linux_x86_64.whl";
+      hash = "sha256-AdqgntXh2rTD7rBePshFAQ2tVl7b+734wG4r471/Y2U=";
     };
     x86_64-linux-38 = {
-      name = "torchaudio-0.10.0-cp38-cp38-linux_x86_64.whl";
-      url = "https://download.pytorch.org/whl/cu113/torchaudio-0.10.0%2Bcu113-cp38-cp38-linux_x86_64.whl";
-      hash = "sha256-Mf7QdXBSIIWRfT7ACthEwFA1V2ieid8legbMnRQnzqI=";
+      name = "torchaudio-0.11.0-cp38-cp38-linux_x86_64.whl";
+      url = "https://download.pytorch.org/whl/cu113/torchaudio-0.11.0%2Bcu113-cp38-cp38-linux_x86_64.whl";
+      hash = "sha256-zuCHDpz3bkOUjYWprqX9VXoUbXfR8Vhdf1VFfOUg8z4=";
     };
     x86_64-linux-39 = {
-      name = "torchaudio-0.10.0-cp39-cp39-linux_x86_64.whl";
-      url = "https://download.pytorch.org/whl/cu113/torchaudio-0.10.0%2Bcu113-cp39-cp39-linux_x86_64.whl";
-      hash = "sha256-LMSGNdmku1iHRy1jCRTTOYcQlRL+Oc9jjZC1nx++skA=";
+      name = "torchaudio-0.11.0-cp39-cp39-linux_x86_64.whl";
+      url = "https://download.pytorch.org/whl/cu113/torchaudio-0.11.0%2Bcu113-cp39-cp39-linux_x86_64.whl";
+      hash = "sha256-btI9TpsOjeLnIz6J56avNv4poJTpXjjhDbMy6+ZFQvI=";
+    };
+    x86_64-linux-310 = {
+      name = "torchaudio-0.11.0-cp310-cp310-linux_x86_64.whl";
+      url = "https://download.pytorch.org/whl/cu113/torchaudio-0.11.0%2Bcu113-cp310-cp310-linux_x86_64.whl";
+      hash = "sha256-Zk+AWytEXfJ+HM69BAPhVsvN6pgQwC6uaW7Xux2row4=";
+    };
+    x86_64-darwin-37 = {
+      name = "torchaudio-0.11.0-cp37-cp37m-macosx_10_15_x86_64.whl";
+      url = "https://download.pytorch.org/whl/torchaudio-0.11.0-cp37-cp37m-macosx_10_15_x86_64.whl";
+      hash = "sha256-uaTT4athEWHAZe0hBoBIM/9LhfZNhAIexZBGg2MWn50=";
+    };
+    x86_64-darwin-38 = {
+      name = "torchaudio-0.11.0-cp38-cp38-macosx_10_15_x86_64.whl";
+      url = "https://download.pytorch.org/whl/torchaudio-0.11.0-cp38-cp38-macosx_10_15_x86_64.whl";
+      hash = "sha256-9OndqejTzgu9XnkZJiGfUFS4uFNlx5vi7pAzOs+a2/w=";
+    };
+    x86_64-darwin-39 = {
+      name = "torchaudio-0.11.0-cp39-cp39-macosx_10_15_x86_64.whl";
+      url = "https://download.pytorch.org/whl/torchaudio-0.11.0-cp39-cp39-macosx_10_15_x86_64.whl";
+      hash = "sha256-cNi8B/J3YI0jqaoI2z+68DVmAlS8EtmzYWQMRVZ3dVk=";
+    };
+    x86_64-darwin-310 = {
+      name = "torchaudio-0.11.0-cp310-cp310-macosx_10_15_x86_64.whl";
+      url = "https://download.pytorch.org/whl/torchaudio-0.11.0-cp310-cp310-macosx_10_15_x86_64.whl";
+      hash = "sha256-g2Pj2wqK9YIP19O/g5agryPcgiHJqdS2Di44mAVJKUQ=";
+    };
+    aarch64-darwin-38 = {
+      name = "torchaudio-0.11.0-cp38-cp38-macosx_11_0_arm64.whl";
+      url = "https://download.pytorch.org/whl/torchaudio-0.11.0-cp38-cp38-macosx_11_0_arm64.whl";
+      hash = "sha256-MX/Y7Dn92zrx2tkGWTuezcPt9o5/V4DEL43pVlha5IA=";
+    };
+    aarch64-darwin-39 = {
+      name = "torchaudio-0.11.0-cp39-cp39-macosx_11_0_arm64.whl";
+      url = "https://download.pytorch.org/whl/torchaudio-0.11.0-cp39-cp39-macosx_11_0_arm64.whl";
+      hash = "sha256-5eVRP83VeHAGGWW++/B2V4eyX0mcPgC1j02ETkQYMXc=";
+    };
+    aarch64-darwin-310 = {
+      name = "torchaudio-0.11.0-cp310-cp310-macosx_11_0_arm64.whl";
+      url = "https://download.pytorch.org/whl/torchaudio-0.11.0-cp310-cp310-macosx_11_0_arm64.whl";
+      hash = "sha256-06OyzOuV8E7ZNtozvFO9Zm2rBxWnnbM65HGYUiQdwtI=";
     };
   };
 }

pkgs/development/python-modules/torchaudio/prefetch.sh

···
 
 version=$1
 
-bucket="https://download.pytorch.org/whl/cu113"
+linux_bucket="https://download.pytorch.org/whl/cu113"
+darwin_bucket="https://download.pytorch.org/whl"
 
 url_and_key_list=(
-  "x86_64-linux-37 $bucket/torchaudio-${version}%2Bcu113-cp37-cp37m-linux_x86_64.whl torchaudio-${version}-cp37-cp37m-linux_x86_64.whl"
-  "x86_64-linux-38 $bucket/torchaudio-${version}%2Bcu113-cp38-cp38-linux_x86_64.whl torchaudio-${version}-cp38-cp38-linux_x86_64.whl"
-  "x86_64-linux-39 $bucket/torchaudio-${version}%2Bcu113-cp39-cp39-linux_x86_64.whl torchaudio-${version}-cp39-cp39-linux_x86_64.whl"
+  "x86_64-linux-37 $linux_bucket/torchaudio-${version}%2Bcu113-cp37-cp37m-linux_x86_64.whl torchaudio-${version}-cp37-cp37m-linux_x86_64.whl"
+  "x86_64-linux-38 $linux_bucket/torchaudio-${version}%2Bcu113-cp38-cp38-linux_x86_64.whl torchaudio-${version}-cp38-cp38-linux_x86_64.whl"
+  "x86_64-linux-39 $linux_bucket/torchaudio-${version}%2Bcu113-cp39-cp39-linux_x86_64.whl torchaudio-${version}-cp39-cp39-linux_x86_64.whl"
+  "x86_64-linux-310 $linux_bucket/torchaudio-${version}%2Bcu113-cp310-cp310-linux_x86_64.whl torchaudio-${version}-cp310-cp310-linux_x86_64.whl"
+  "x86_64-darwin-37 $darwin_bucket/torchaudio-${version}-cp37-cp37m-macosx_10_15_x86_64.whl torchaudio-${version}-cp37-cp37m-macosx_10_15_x86_64.whl"
+  "x86_64-darwin-38 $darwin_bucket/torchaudio-${version}-cp38-cp38-macosx_10_15_x86_64.whl torchaudio-${version}-cp38-cp38-macosx_10_15_x86_64.whl"
+  "x86_64-darwin-39 $darwin_bucket/torchaudio-${version}-cp39-cp39-macosx_10_15_x86_64.whl torchaudio-${version}-cp39-cp39-macosx_10_15_x86_64.whl"
+  "x86_64-darwin-310 $darwin_bucket/torchaudio-${version}-cp310-cp310-macosx_10_15_x86_64.whl torchaudio-${version}-cp310-cp310-macosx_10_15_x86_64.whl"
+  "aarch64-darwin-38 $darwin_bucket/torchaudio-${version}-cp38-cp38-macosx_11_0_arm64.whl torchaudio-${version}-cp38-cp38-macosx_11_0_arm64.whl"
+  "aarch64-darwin-39 $darwin_bucket/torchaudio-${version}-cp39-cp39-macosx_11_0_arm64.whl torchaudio-${version}-cp39-cp39-macosx_11_0_arm64.whl"
+  "aarch64-darwin-310 $darwin_bucket/torchaudio-${version}-cp310-cp310-macosx_11_0_arm64.whl torchaudio-${version}-cp310-cp310-macosx_11_0_arm64.whl"
 )
 
 hashfile=binary-hashes-"$version".nix

pkgs/development/python-modules/torchvision/bin.nix

···
 , isPy37
 , isPy38
 , isPy39
+, isPy310
 , patchelf
 , pillow
 , python
···
   pyVerNoDot = builtins.replaceStrings [ "." ] [ "" ] python.pythonVersion;
   srcs = import ./binary-hashes.nix version;
   unsupported = throw "Unsupported system";
-  version = "0.11.1";
+  version = "0.12.0";
 in buildPythonPackage {
   inherit version;
 
···
 
   src = fetchurl srcs."${stdenv.system}-${pyVerNoDot}" or unsupported;
 
-  disabled = !(isPy37 || isPy38 || isPy39);
+  disabled = !(isPy37 || isPy38 || isPy39 || isPy310);
 
   nativeBuildInputs = [
     patchelf

pkgs/development/python-modules/torchvision/binary-hashes.nix

···
 # To add a new version, run "prefetch.sh 'new-version'" to paste the generated file as follows.
 
 version : builtins.getAttr version {
-  "0.11.1" = {
+  "0.12.0" = {
     x86_64-linux-37 = {
-      name = "torchvision-0.11.1-cp37-cp37m-linux_x86_64.whl";
-      url = "https://download.pytorch.org/whl/cu113/torchvision-0.11.1%2Bcu113-cp37-cp37m-linux_x86_64.whl";
-      hash = "sha256-2xKWqWNKqmOMyVJnPfbtF+B9PQ7z4S66J1T3P8EvM0I=";
+      name = "torchvision-0.12.0-cp37-cp37m-linux_x86_64.whl";
+      url = "https://download.pytorch.org/whl/cu113/torchvision-0.12.0%2Bcu113-cp37-cp37m-linux_x86_64.whl";
+      hash = "sha256-i/qktZT+5HQYQjtTHtxOV751DcsP9AHMsSV9/svsGzA=";
     };
     x86_64-linux-38 = {
-      name = "torchvision-0.11.1-cp38-cp38-linux_x86_64.whl";
-      url = "https://download.pytorch.org/whl/cu113/torchvision-0.11.1%2Bcu113-cp38-cp38-linux_x86_64.whl";
-      hash = "sha256-bFxvJaNEomytXXANHng+oU8YSLGkuO/TSzkoDskkaIE=";
+      name = "torchvision-0.12.0-cp38-cp38-linux_x86_64.whl";
+      url = "https://download.pytorch.org/whl/cu113/torchvision-0.12.0%2Bcu113-cp38-cp38-linux_x86_64.whl";
+      hash = "sha256-NxM+jFsOwvAZmeWRFvbQ422a+xx/j1i9DD3ImW+DVBk=";
     };
     x86_64-linux-39 = {
-      name = "torchvision-0.11.1-cp39-cp39-linux_x86_64.whl";
-      url = "https://download.pytorch.org/whl/cu113/torchvision-0.11.1%2Bcu113-cp39-cp39-linux_x86_64.whl";
-      hash = "sha256-ysN3LmSKR+FVKYGnCGQJqa8lVApVT5rPMO+NHmmazAc=";
+      name = "torchvision-0.12.0-cp39-cp39-linux_x86_64.whl";
+      url = "https://download.pytorch.org/whl/cu113/torchvision-0.12.0%2Bcu113-cp39-cp39-linux_x86_64.whl";
+      hash = "sha256-bGO5q+KEnv7SexmbbUWaIbsBcIxyDbL8pevZQbLwDbg=";
+    };
+    x86_64-linux-310 = {
+      name = "torchvision-0.12.0-cp310-cp310-linux_x86_64.whl";
+      url = "https://download.pytorch.org/whl/cu113/torchvision-0.12.0%2Bcu113-cp310-cp310-linux_x86_64.whl";
+      hash = "sha256-ocsGOHa967HcZGV+1omD/xMHufmoi166Yg2Hr+SEhfE=";
+    };
+    x86_64-darwin-37 = {
+      name = "torchvision-0.12.0-cp37-cp37m-macosx_10_9_x86_64.whl";
+      url = "https://download.pytorch.org/whl/torchvision-0.12.0-cp37-cp37m-macosx_10_9_x86_64.whl";
+      hash = "sha256-GJM7xZf0VjmTJJcZqWqV28fTN0yQ+7MNPafVGPOv60I=";
+    };
+    x86_64-darwin-38 = {
+      name = "torchvision-0.12.0-cp38-cp38-macosx_10_9_x86_64.whl";
+      url = "https://download.pytorch.org/whl/torchvision-0.12.0-cp38-cp38-macosx_10_9_x86_64.whl";
+      hash = "sha256-DWAuCb1Fc2/y55aOjduw7s6Vb/ltcVSLGxtIeP33S9g=";
+    };
+    x86_64-darwin-39 = {
+      name = "torchvision-0.12.0-cp39-cp39-macosx_10_9_x86_64.whl";
+      url = "https://download.pytorch.org/whl/torchvision-0.12.0-cp39-cp39-macosx_10_9_x86_64.whl";
+      hash = "sha256-RMye+ZLS4qtjsIg/fezrwiRNupO3JUe6EfV6yEUvbq0=";
+    };
+    x86_64-darwin-310 = {
+      name = "torchvision-0.12.0-cp310-cp310-macosx_10_9_x86_64.whl";
+      url = "https://download.pytorch.org/whl/torchvision-0.12.0-cp310-cp310-macosx_10_9_x86_64.whl";
+      hash = "sha256-aTZW5nkLarIeSm6H6BwpgrrZ5FW16yThS7ZyOC7GEw8=";
+    };
+    aarch64-darwin-38 = {
+      name = "torchvision-0.12.0-cp38-cp38-macosx_11_0_arm64.whl";
+      url = "https://download.pytorch.org/whl/torchvision-0.12.0-cp38-cp38-macosx_11_0_arm64.whl";
+      hash = "sha256-n0JCD38LKc09YXdt8xV4JyV6DPFrLAJ3bcFslquxJW0=";
+    };
+    aarch64-darwin-39 = {
+      name = "torchvision-0.12.0-cp39-cp39-macosx_11_0_arm64.whl";
+      url = "https://download.pytorch.org/whl/torchvision-0.12.0-cp39-cp39-macosx_11_0_arm64.whl";
+      hash = "sha256-adgvR7Z7rW3cu4eDO6WVCmwnG6l7quTAlVYQBxvwNPU=";
+    };
+    aarch64-darwin-310 = {
+      name = "torchvision-0.12.0-cp310-cp310-macosx_11_0_arm64.whl";
+      url = "https://download.pytorch.org/whl/torchvision-0.12.0-cp310-cp310-macosx_11_0_arm64.whl";
+      hash = "sha256-oL5FAcoLobGVZEySQ/SaHEmiblKn83kkxCOdC/XsvY0=";
     };
   };
 }

pkgs/development/python-modules/torchvision/prefetch.sh

···
 
 version=$1
 
-bucket="https://download.pytorch.org/whl/cu113"
+linux_bucket="https://download.pytorch.org/whl/cu113"
+darwin_bucket="https://download.pytorch.org/whl"
 
 url_and_key_list=(
-  "x86_64-linux-37 $bucket/torchvision-${version}%2Bcu113-cp37-cp37m-linux_x86_64.whl torchvision-${version}-cp37-cp37m-linux_x86_64.whl"
-  "x86_64-linux-38 $bucket/torchvision-${version}%2Bcu113-cp38-cp38-linux_x86_64.whl torchvision-${version}-cp38-cp38-linux_x86_64.whl"
-  "x86_64-linux-39 $bucket/torchvision-${version}%2Bcu113-cp39-cp39-linux_x86_64.whl torchvision-${version}-cp39-cp39-linux_x86_64.whl"
+  "x86_64-linux-37 $linux_bucket/torchvision-${version}%2Bcu113-cp37-cp37m-linux_x86_64.whl torchvision-${version}-cp37-cp37m-linux_x86_64.whl"
+  "x86_64-linux-38 $linux_bucket/torchvision-${version}%2Bcu113-cp38-cp38-linux_x86_64.whl torchvision-${version}-cp38-cp38-linux_x86_64.whl"
+  "x86_64-linux-39 $linux_bucket/torchvision-${version}%2Bcu113-cp39-cp39-linux_x86_64.whl torchvision-${version}-cp39-cp39-linux_x86_64.whl"
+  "x86_64-linux-310 $linux_bucket/torchvision-${version}%2Bcu113-cp310-cp310-linux_x86_64.whl torchvision-${version}-cp310-cp310-linux_x86_64.whl"
+  "x86_64-darwin-37 $darwin_bucket/torchvision-${version}-cp37-cp37m-macosx_10_9_x86_64.whl torchvision-${version}-cp37-cp37m-macosx_10_9_x86_64.whl"
+  "x86_64-darwin-38 $darwin_bucket/torchvision-${version}-cp38-cp38-macosx_10_9_x86_64.whl torchvision-${version}-cp38-cp38-macosx_10_9_x86_64.whl"
+  "x86_64-darwin-39 $darwin_bucket/torchvision-${version}-cp39-cp39-macosx_10_9_x86_64.whl torchvision-${version}-cp39-cp39-macosx_10_9_x86_64.whl"
+  "x86_64-darwin-310 $darwin_bucket/torchvision-${version}-cp310-cp310-macosx_10_9_x86_64.whl torchvision-${version}-cp310-cp310-macosx_10_9_x86_64.whl"
+  "aarch64-darwin-38 $darwin_bucket/torchvision-${version}-cp38-cp38-macosx_11_0_arm64.whl torchvision-${version}-cp38-cp38-macosx_11_0_arm64.whl"
+  "aarch64-darwin-39 $darwin_bucket/torchvision-${version}-cp39-cp39-macosx_11_0_arm64.whl torchvision-${version}-cp39-cp39-macosx_11_0_arm64.whl"
+  "aarch64-darwin-310 $darwin_bucket/torchvision-${version}-cp310-cp310-macosx_11_0_arm64.whl torchvision-${version}-cp310-cp310-macosx_11_0_arm64.whl"
 )
 
 hashfile="binary-hashes-$version.nix"

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

···
 
 buildPythonPackage rec {
   pname = "trimesh";
-  version = "3.10.5";
+  version = "3.10.6";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "sha256-GtdxStdWtioRgf/Y2/broyYElqIJ2RxP3otgROw3epI=";
+    sha256 = "sha256-oFNJ2hynf4bUY6sIXx7y4jEkCATi5rZetiCvNpwNzio=";
   };
 
   propagatedBuildInputs = [ numpy ];

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

···
 }:
 buildPythonPackage rec {
   pname = "Twisted";
-  version = "21.7.0";
+  version = "22.2.0";
 
   src = fetchPypi {
     inherit pname version;
     extension = "tar.gz";
-    sha256 = "01lh225d7lfnmfx4f4kxwl3963gjc9yg8jfkn1w769v34ia55mic";
+    sha256 = "1wml02jxni8k15984pskks7d6yin81w4d2ac026cpyiqd0gjpwsp";
   };
 
   propagatedBuildInputs = [ zope_interface incremental automat constantly hyperlink pyhamcrest attrs setuptools typing-extensions ];

pkgs/development/tools/analysis/checkov/default.nix

···
 
 buildPythonApplication rec {
   pname = "checkov";
-  version = "2.0.975";
+  version = "2.0.988";
 
   src = fetchFromGitHub {
     owner = "bridgecrewio";
     repo = pname;
     rev = version;
-    hash = "sha256-vzq6HKugjM9LBaklv0IlMauSAl3bqHOikDCzrhVBVPA=";
+    hash = "sha256-0/SL20N5d/oqWdyvVMZ+pzpPbehrYepaPi8P8SS8DSA=";
   };
 
   nativeBuildInputs = with py.pkgs; [

pkgs/development/tools/analysis/tfsec/default.nix

···
 
 buildGoModule rec {
   pname = "tfsec";
-  version = "1.13.0";
+  version = "1.13.2";
 
   src = fetchFromGitHub {
     owner = "aquasecurity";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-/N8p/tw97sDW4I1ysfJ2QXACGsSc5nRFSu6jHwQvPU4=";
+    sha256 = "sha256-ixiuAm1MCLS7daUwiFUPoO86YOoz9qEkQT5i/YlIdf0=";
   };
 
   ldflags = [
···
     # "-extldflags '-fno-PIC -static'"
   ];
 
-  vendorSha256 = "sha256-nTma96kT84mpJHRA9+/sZQVvwtz9arv/OHY9lgWJDFc=";
+  vendorSha256 = "sha256-WlZJvBIdJCMA+GJ0svEzwqrdPz2wnlJx/csVarjyExw=";
 
   subPackages = [
     "cmd/tfsec"

pkgs/development/tools/earthly/default.nix

···
 
 buildGoModule rec {
   pname = "earthly";
-  version = "0.6.11";
+  version = "0.6.12";
 
   src = fetchFromGitHub {
     owner = "earthly";
     repo = "earthly";
     rev = "v${version}";
-    sha256 = "sha256-awlE+k4Oa64Z2n+XbeDuezea+5D0ol7hyscVY6j52gI=";
+    sha256 = "sha256-M8DnSpQhW4i83cu9wp0ZKyP7137IQVjyBl0cgVvQmPI=";
   };
 
-  vendorSha256 = "sha256-uUx9C7uEdXjhDWxehGHuhuFQXdUjZAXK3qogESkRm8E=";
+  vendorSha256 = "sha256-GvTWj0uEsCyC4/RL6woym8UwA3OCFx8NWkNQApnVMM8=";
 
   ldflags = [
     "-s" "-w"

pkgs/development/tools/efm-langserver/default.nix

···
 
 buildGoModule rec {
   pname = "efm-langserver";
-  version = "0.0.41";
+  version = "0.0.42";
 
   src = fetchFromGitHub {
     owner = "mattn";
     repo = "efm-langserver";
     rev = "v${version}";
-    sha256 = "sha256-0s6GmMbjtXGUcChzc8Pkqvmt3iU5uDUqe76OUDngboU=";
+    sha256 = "sha256-1IAPtqIozp9Wp3L95mmhFuWvWvCDuTh1VsCVaJSzyfk=";
   };
 
-  vendorSha256 = "sha256-tca+1SRrFyvU8ttHmfMFiGXd1A8rQSEWm1Mc2qp0EfI=";
+  vendorSha256 = "sha256-KABezphT5/o3XWSFNe2OvfawFR8uwsGMnjsI9xh378Q=";
   subPackages = [ "." ];
 
   meta = with lib; {

pkgs/development/tools/glade/default.nix

···
-{ lib, stdenv
+{ stdenv
+, lib
 , gettext
 , fetchurl
+, fetchpatch
 , python3
 , meson
 , ninja
···
     url = "mirror://gnome/sources/glade/${lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
     sha256 = "1dxsiz9ahqkxg2a1dw9sbd8jg59y5pdz4c1gvnbmql48gmj8gz4q";
   };
+
+  patches = [
+    # Fix build with meson 0.61
+    # data/meson.build:4:5: ERROR: Function does not take positional arguments.
+    # Taken from https://gitlab.gnome.org/GNOME/glade/-/merge_requests/117
+    (fetchpatch {
+      url = "https://gitlab.gnome.org/GNOME/glade/-/commit/61304b2e8bac8ded76643cb7c3e781f73881dd2b.patch";
+      sha256 = "9x6RK8Wgnm8bDxeBLV3PlUkUuH2706Ba9kwE5S87DgE=";
+    })
+    # help/meson.build:6:6: ERROR: Tried to create target "help-glade-da-update-po", but a target of that name already exists.
+    # Taken from https://gitlab.gnome.org/GNOME/glade/-/merge_requests/117
+    (fetchpatch {
+      url = "https://gitlab.gnome.org/GNOME/glade/-/commit/04ba6f969f716fbfe3c7feb7e4bab8678cc1e9eb.patch";
+      sha256 = "j3XfF7P6rndL+0PWqnp+QYph7Ba6bgcp4Pkikr2wuJA=";
+    })
+  ];
 
   nativeBuildInputs = [
     meson

pkgs/development/tools/jql/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "jql";
-  version = "3.1.2";
+  version = "3.1.3";
 
   src = fetchFromGitHub {
     owner = "yamafaktory";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-UC+1I87PPDuu+/A5zO2Q/Z5KbO/5jHuxsJ0r7a+uDLM=";
+    sha256 = "sha256-kYAVgQa5NAfZ7EVzO/3fW3A5Zl8uaFXguvxBco8DfRY=";
   };
 
-  cargoSha256 = "sha256-0ezrcploLboYExcRzNnKj/vWgbJuBhteWi/Imlr4Wsg=";
+  cargoSha256 = "sha256-Mz+1A7Wg7sh0pxg7umRym3UkXsMkRE0AQDTkt+e7l+s=";
 
   meta = with lib; {
     description = "A JSON Query Language CLI tool built with Rust";

pkgs/development/tools/kube-linter/default.nix

···
 
 buildGoModule rec {
   pname = "kube-linter";
-  version = "0.2.5";
+  version = "0.2.6";
 
   src = fetchFromGitHub {
     owner = "stackrox";
     repo = pname;
     rev = "${version}";
-    sha256 = "GUDrUEBorV4/ZqPnfNYcsbW4Zr1LpS3yL+4OgxFbTOk=";
+    sha256 = "nBF/AX4hgZxIj9/RYowpHX1eAJMMhvU7wunvEXWnO80=";
   };
 
-  vendorSha256 = "xGghTP9thICOGIfc5VPJK06DeXfLiTckwa4nXv83/P8=";
+  vendorSha256 = "HJW28BZ9qFLtdH1qdW8/K4TzHA2ptekXaMF0XnMKbOY=";
 
   ldflags = [
     "-s" "-w" "-X golang.stackrox.io/kube-linter/internal/version.version=${version}"

pkgs/development/tools/ocaml/cppo/default.nix

···
   makeFlags = [ "PREFIX=$(out)" ];
 
   preBuild = ''
-    mkdir $out/bin
+    mkdir -p $out/bin
   '';
 
 }

pkgs/development/tools/oras/default.nix

···
+{ lib, stdenv, buildGoModule, fetchFromGitHub }:
+
+buildGoModule rec {
+  pname = "oras";
+  version = "0.12.0";
+
+  src = fetchFromGitHub {
+    owner = "oras-project";
+    repo = "oras";
+    rev = "v${version}";
+    sha256 = "sha256-6W7vmWFjULIJnOVtgSrCEKw/83W8jNSbM0AF4LZZR6U=";
+  };
+  vendorSha256 = "sha256-3UKsH4Jbq7G5PRwhn5lW0NR80jhmuzT9daa++v2sFWk=";
+
+  ldflags = [
+    "-s"
+    "-w"
+    "-X github.com/oras-project/oras/internal/version.Version=${version}"
+    "-X github.com/oras-project/oras/internal/version.BuildMetadata="
+    "-X github.com/oras-project/oras/internal/version.GitTreeState=clean"
+  ];
+
+  doInstallCheck = true;
+  installCheckPhase = ''
+    runHook preInstallCheck
+
+    $out/bin/oras --help
+    $out/bin/oras version | grep "${version}"
+
+    runHook postInstallCheck
+  '';
+
+  meta = with lib; {
+    homepage = "https://oras.land/";
+    changelog = "https://github.com/oras-project/oras/releases/tag/v${version}";
+    description = "The ORAS project provides a way to push and pull OCI Artifacts to and from OCI Registries";
+    license = licenses.asl20;
+    maintainers = with maintainers; [ jk ];
+  };
+}

pkgs/development/tools/pipenv/default.nix

···
 
 in buildPythonApplication rec {
   pname = "pipenv";
-  version = "2022.1.8";
+  version = "2022.3.23";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "f84d7119239b22ab2ac2b8fbc7d619d83cf41135206d72a17c4f151cda529fd0";
+    sha256 = "sha256-pt9BdR31VTfe5UNJ4dy3eB586zS7mFsITphafg3EP8U=";
   };
 
   LC_ALL = "en_US.UTF-8";

pkgs/development/tools/skopeo/default.nix

···
 
 buildGoModule rec {
   pname = "skopeo";
-  version = "1.6.1";
+  version = "1.7.0";
 
   src = fetchFromGitHub {
     rev = "v${version}";
     owner = "containers";
     repo = "skopeo";
-    sha256 = "sha256-L3dHkF7yKnwXpXxCEswwA0TxVfjTzc89l0rpT7EYpIU=";
+    sha256 = "sha256-sbe16IcHkhsiBznsMKtG/xYJYJfJS6aZ34++QhkGTTc=";
   };
 
   outputs = [ "out" "man" ];

pkgs/development/tools/wrangler/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "wrangler";
-  version = "1.19.9";
+  version = "1.19.10";
 
   src = fetchFromGitHub {
     owner = "cloudflare";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-cuntghTMGrAcrPunyi9ZWlxDcryYv7R6S3V8WJjEUtQ=";
+    sha256 = "sha256-RKOAs7MRHcGx6BNBml7WQ81bNvdB9ipd0R1ErLTwjTQ=";
   };
 
-  cargoSha256 = "sha256-gao8vCfzb81GUte6WAt2x/pxecg443bpQxvUSQCXL40=";
+  cargoSha256 = "sha256-9GvKDLuDIW5q1R5g20rtSScv2c0sLSo+hI9LSA4W3M8=";
 
   nativeBuildInputs = [ pkg-config ];
 

pkgs/development/tools/yarn2nix-moretea/yarn2nix/default.nix

···
     preBuild ? "",
     postBuild ? "",
     workspaceDependencies ? [], # List of yarn packages
+    packageResolutions ? {},
   }:
     let
       extraNativeBuildInputs =
···
 
       workspaceJSON = pkgs.writeText
         "${name}-workspace-package.json"
-        (builtins.toJSON { private = true; workspaces = ["deps/**"]; }); # scoped packages need second splat
+        (builtins.toJSON { private = true; workspaces = ["deps/**"]; resolutions = packageResolutions; }); # scoped packages need second splat
 
       workspaceDependencyLinks = lib.concatMapStringsSep "\n"
         (dep: ''
···
 
     packageGlobs = if lib.isList package.workspaces then package.workspaces else package.workspaces.packages;
 
+    packageResolutions = package.resolutions or {};
+
     globElemToRegex = lib.replaceStrings ["*"] [".*"];
 
     # PathGlob -> [PathGlobElem]
···
         inherit name;
         value = mkYarnPackage (
           builtins.removeAttrs attrs ["packageOverrides"]
-          // { inherit src packageJSON yarnLock workspaceDependencies; }
+          // { inherit src packageJSON yarnLock packageResolutions workspaceDependencies; }
           // lib.attrByPath [name] {} packageOverrides
         );
       })
···
     extraBuildInputs ? [],
     publishBinsFor ? null,
     workspaceDependencies ? [], # List of yarnPackages
+    packageResolutions ? {},
     ...
   }@attrs:
     let
···
         preBuild = yarnPreBuild;
         postBuild = yarnPostBuild;
         workspaceDependencies = workspaceDependenciesTransitive;
-        inherit packageJSON pname version yarnLock offlineCache yarnFlags pkgConfig;
+        inherit packageJSON pname version yarnLock offlineCache yarnFlags pkgConfig packageResolutions;
       };
 
       publishBinsFor_ = unlessNull publishBinsFor [pname];
···
         '')
         workspaceDependenciesTransitive;
 
-    in stdenv.mkDerivation (builtins.removeAttrs attrs ["yarnNix" "pkgConfig" "workspaceDependencies"] // {
+    in stdenv.mkDerivation (builtins.removeAttrs attrs ["yarnNix" "pkgConfig" "workspaceDependencies" "packageResolutions"] // {
       inherit src pname;
 
       name = baseName;

pkgs/development/web/kore/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "kore";
-  version = "4.1.0";
+  version = "4.2.1";
 
   src = fetchFromGitHub {
     owner = "jorisvink";
     repo = pname;
     rev = version;
-    sha256 = "sha256-w5H1USQ2aladwSFdfYsX925pjCt3QWoXK4HqyEL7rH0=";
+    sha256 = "sha256-MC4PCjRuAqWuGvNDsZXKohb4HdSWMV0Oc0pZ0rnhG7Y=";
   };
 
   buildInputs = [ openssl curl postgresql yajl ];

pkgs/games/steam/fhsenv.nix

···
         export TZ="$new_TZ"
       fi
     fi
-
-    # XDG_DATA_DIRS is used by pressure-vessel and vulkan loaders to find the corresponding icd
-    export XDG_DATA_DIRS=$XDG_DATA_DIRS''${XDG_DATA_DIRS:+:}/run/opengl-driver/share:/run/opengl-driver-32/share
   '' + extraProfile;
 
   runScript = writeScript "steam-wrapper.sh" ''

pkgs/os-specific/linux/earlyoom/default.nix

···
-{ lib, stdenv, fetchFromGitHub, pandoc, installShellFiles, withManpage ? false }:
+{ lib, stdenv, fetchFromGitHub, pandoc, installShellFiles, withManpage ? false, nixosTests }:
 
 stdenv.mkDerivation rec {
   pname = "earlyoom";
···
   '' + lib.optionalString withManpage ''
     installManPage earlyoom.1
   '';
+
+  passthru.tests = {
+    inherit (nixosTests) earlyoom;
+  };
 
   meta = with lib; {
     description = "Early OOM Daemon for Linux";

pkgs/os-specific/linux/kernel/common-config.nix

···
       DEFAULT_SECURITY_APPARMOR        = yes;
 
       RANDOM_TRUST_CPU                 = whenAtLeast "4.19" yes; # allow RDRAND to seed the RNG
+      RANDOM_TRUST_BOOTLOADER          = whenAtLeast "5.4" yes; # allow the bootloader to seed the RNG
 
       MODULE_SIG            = no; # r13y, generates a random key during build and bakes it in
       # Depends on MODULE_SIG and only really helps when you sign your modules

pkgs/servers/dns/https-dns-proxy/default.nix

···
 stdenv.mkDerivation rec {
   pname = "https-dns-proxy";
   # there are no stable releases (yet?)
-  version = "unstable-20200419";
+  version = "unstable-2021-03-29";
 
   src = fetchFromGitHub {
     owner = "aarond10";
     repo = "https_dns_proxy";
-    rev = "79fc7b085e3b1ad64c8332f7115dfe2bf5f1f3e4";
-    sha256 = "1cdfswfjby4alp6gy7yyjm76kfyclh5ax0zadnqs2pyigg9plh0b";
+    rev = "bbd9ef272dcda3ead515871f594768af13192af7";
+    sha256 = "sha256-r+IpDklI3vITK8ZlZvIFm3JdDe2r8DK2ND3n1a/ThrM=";
   };
 
   nativeBuildInputs = [ cmake gtest ];

pkgs/servers/monitoring/prometheus/node-exporter.nix

···
-{ lib, buildGoModule, fetchFromGitHub, nixosTests }:
+{ lib, stdenv, buildGoModule, fetchFromGitHub, nixosTests
+  # darwin
+  , CoreFoundation, IOKit
+}:
 
 buildGoModule rec {
   pname = "node_exporter";
···
 
   # FIXME: tests fail due to read-only nix store
   doCheck = false;
+
+  buildInputs = lib.optionals stdenv.isDarwin [ CoreFoundation IOKit ];
+  # upstream currently doesn't work with the version of the macOS SDK
+  # we're building against in nix-darwin without a patch.
+  # this patch has been submitted upstream at https://github.com/prometheus/node_exporter/pull/2327
+  # and only needs to be carried until it lands in a new release.
+  patches = lib.optionals stdenv.isDarwin [ ./node-exporter/node-exporter-darwin.patch ];
 
   excludedPackages = [ "docs/node-mixin" ];
 

pkgs/servers/monitoring/prometheus/node-exporter/node-exporter-darwin.patch

···
+diff --git a/collector/powersupplyclass_darwin.go b/collector/powersupplyclass_darwin.go
+index a070f64..01d7f18 100644
+--- a/collector/powersupplyclass_darwin.go
++++ b/collector/powersupplyclass_darwin.go
+@@ -18,9 +18,11 @@ package collector
+ 
+ /*
+ #cgo LDFLAGS: -framework IOKit -framework CoreFoundation
++#include <CoreFoundation/CFNumber.h>
++#include <CoreFoundation/CFRunLoop.h>
++#include <CoreFoundation/CFString.h>
+ #include <IOKit/ps/IOPowerSources.h>
+ #include <IOKit/ps/IOPSKeys.h>
+-#include <CoreFoundation/CFArray.h>
+ 
+ // values collected from IOKit Power Source APIs
+ // Functions documentation available at

pkgs/servers/nextcloud/default.nix

···
   '';
 
   nextcloud22 = generic {
-    version = "22.2.5";
-    sha256 = "sha256-gb5N0u5tu4/nI2xIpjXwm2hiSDCrBhIDyN6gKGOsdS8=";
+    version = "22.2.6";
+    sha256 = "0f1d0f0cb000c51b11886be25a8adce478846c3233572fcf28b44c5d4036e235";
   };
 
   nextcloud23 = generic {
-    version = "23.0.2";
-    sha256 = "sha256-ngJGLTjqq2RX/KgHe9Rv54w6qtRC6RpuEuMvp9UbxO4=";
+    version = "23.0.3";
+    sha256 = "39401d400fab02a84a175ea6e995b8ed4110fbaea48c876230b4f09755a62986";
   };
   # tip: get she sha with:
   # curl 'https://download.nextcloud.com/server/releases/nextcloud-${version}.tar.bz2.sha256'

pkgs/servers/plex/raw.nix

···
 # server, and the FHS userenv and corresponding NixOS module should
 # automatically pick up the changes.
 stdenv.mkDerivation rec {
-  version = "1.25.7.5604-980a13e02";
+  version = "1.25.8.5663-e071c3d62";
   pname = "plexmediaserver";
 
   # Fetch the source
   src = if stdenv.hostPlatform.system == "aarch64-linux" then fetchurl {
     url = "https://downloads.plex.tv/plex-media-server-new/${version}/debian/plexmediaserver_${version}_arm64.deb";
-    hash = "sha256-X0KaaX5NvF04pyRHSUeHtXQ+OTv9BK0bzDl1J5C6Vts=";
+    hash = "sha256-w9k8phyiA/sK+zRlK8PAciebt5UJvmVFA+cfx4r78Gs=";
   } else fetchurl {
     url = "https://downloads.plex.tv/plex-media-server-new/${version}/debian/plexmediaserver_${version}_amd64.deb";
-    hash = "sha256-tqpOQDdHBl55jSyonNV7/UjCcx6jY9VdAzh/zBA/CAs=";
+    hash = "sha256-baOofe+7PZfLhwIXrB1ibKkkEJRVivgGHDN4phlg57Q=";
   };
 
   outputs = [ "out" "basedb" ];

pkgs/test/nixos-functions/default.nix

···
       fileSystems."/".device = "/dev/null";
     }).toplevel;
 
-    nixosTest-test = pkgs.nixosTest ({ lib, pkgs, ... }: {
+    nixosTest-test = pkgs.nixosTest ({ lib, pkgs, figlet, ... }: {
       name = "nixosTest-test";
       machine = { pkgs, ... }: {
         system.nixos = dummyVersioning;
-        environment.systemPackages = [ pkgs.hello ];
+        environment.systemPackages = [ pkgs.hello figlet ];
       };
       testScript = ''
-        machine.succeed("hello")
+        machine.succeed("hello | figlet >/dev/console")
       '';
     });
 

pkgs/tools/admin/pulumi/data.nix

···
         sha256 = "07zwhy1jfgwqcybyalrlwrqfkddk1xkqgb9g8dmgs2krx8fp9bsv";
       }
       {
-        url = "https://api.pulumi.com/releases/plugins/pulumi-resource-aws-v4.38.1-linux-amd64.tar.gz";
-        sha256 = "0rwkdizd1hqn86vfkxli7l4syp860rgil2m01l76pbpcx11yc7zb";
+        url = "https://api.pulumi.com/releases/plugins/pulumi-resource-aws-v5.0.0-linux-amd64.tar.gz";
+        sha256 = "1h9pypyl6k1qhvwd6vkzahwmva6zbjribfh04rydhw4gn3rhlzrd";
       }
       {
         url = "https://api.pulumi.com/releases/plugins/pulumi-resource-azuread-v5.18.0-linux-amd64.tar.gz";
···
         sha256 = "0n1xqsfsqi773lwg9xbvglrd4pfb060fq8llxf06qj8h2imlxx34";
       }
       {
-        url = "https://api.pulumi.com/releases/plugins/pulumi-resource-gcp-v6.16.0-linux-amd64.tar.gz";
-        sha256 = "10lm10affn92qwzgry2iab5ry6bcnx5iiy2cihxk9kgb6716wql3";
+        url = "https://api.pulumi.com/releases/plugins/pulumi-resource-gcp-v6.17.0-linux-amd64.tar.gz";
+        sha256 = "1dbkkrb66iz2z66bj6qhhwhaz3s0md1xgm4mgw0bcdlirkrv1kpd";
       }
       {
-        url = "https://api.pulumi.com/releases/plugins/pulumi-resource-github-v4.10.0-linux-amd64.tar.gz";
-        sha256 = "1lni4wzmdhjbchjjx9z5iqawv4x1bixl3s541h39cr4x3y36m66m";
+        url = "https://api.pulumi.com/releases/plugins/pulumi-resource-github-v4.10.1-linux-amd64.tar.gz";
+        sha256 = "0bs0haa863a2qwwx140911mh2xprgyv316y98jcm8qbl03lmyzvs";
       }
       {
         url = "https://api.pulumi.com/releases/plugins/pulumi-resource-gitlab-v4.6.0-linux-amd64.tar.gz";
···
         sha256 = "05nfdwgfzi5f3hgj2g6dccaidqf9a9xzlv5vp3cd1rsxd159yk9j";
       }
       {
-        url = "https://api.pulumi.com/releases/plugins/pulumi-resource-random-v4.4.1-linux-amd64.tar.gz";
-        sha256 = "1yianshwmlxs70h4a19c9006n29rp6qz3nf6n0kb5l52psmq679m";
+        url = "https://api.pulumi.com/releases/plugins/pulumi-resource-random-v4.4.2-linux-amd64.tar.gz";
+        sha256 = "0agf96ji7mzkf4k4axm1v3psm5wkml41714dz88rn0csq0b31ca9";
       }
       {
-        url = "https://api.pulumi.com/releases/plugins/pulumi-resource-snowflake-v0.5.1-linux-amd64.tar.gz";
-        sha256 = "0a1q41cl9r93n8zvl25sd33mxvi0ysa10lz84x59sybfay4f7ppc";
+        url = "https://api.pulumi.com/releases/plugins/pulumi-resource-snowflake-v0.5.2-linux-amd64.tar.gz";
+        sha256 = "0b3sj2waa3l6x4xrrsf1dq4ax3n7v5r8n0wzmk9cbgmdx97297df";
       }
       {
         url = "https://api.pulumi.com/releases/plugins/pulumi-resource-spotinst-v3.15.0-linux-amd64.tar.gz";
···
         sha256 = "0bz177xi0ifhx14jq01i94gdqgjsivikmhrf24y27k96jq7n15ld";
       }
       {
-        url = "https://api.pulumi.com/releases/plugins/pulumi-resource-aws-v4.38.1-darwin-amd64.tar.gz";
-        sha256 = "0qaf9q7ijkysvvnxrb942c2r6hj4y97kjfxnlwgjx1jvnv1l9859";
+        url = "https://api.pulumi.com/releases/plugins/pulumi-resource-aws-v5.0.0-darwin-amd64.tar.gz";
+        sha256 = "1kw005yvima4bjkg5sa8ynixgrcapdbcnxd6s4qpgjli6q4imx8h";
       }
       {
         url = "https://api.pulumi.com/releases/plugins/pulumi-resource-azuread-v5.18.0-darwin-amd64.tar.gz";
···
         sha256 = "0i3aysdy7i13fx2a2kpnvd3qpn7vmc2mbln718kks3mikiz26aii";
       }
       {
-        url = "https://api.pulumi.com/releases/plugins/pulumi-resource-gcp-v6.16.0-darwin-amd64.tar.gz";
-        sha256 = "1sdir66pqdxy5zwbx1ssv8bl63zvbzfapl3j5dl99zgjaw4k3mgx";
+        url = "https://api.pulumi.com/releases/plugins/pulumi-resource-gcp-v6.17.0-darwin-amd64.tar.gz";
+        sha256 = "1cwdy4yr3c7wcj3p0sg1k0q6b6sn0mhlpqkbdi4xfk990d88c78c";
       }
       {
-        url = "https://api.pulumi.com/releases/plugins/pulumi-resource-github-v4.10.0-darwin-amd64.tar.gz";
-        sha256 = "0i49x5s7sw69y19qmsrbrwhmjv7g07qrs5a3l1l8bsqawif5r65z";
+        url = "https://api.pulumi.com/releases/plugins/pulumi-resource-github-v4.10.1-darwin-amd64.tar.gz";
+        sha256 = "0a8lycsgk2xawhg9yd6lkbfg7j6v6l3m0llvdzs0drb2k954wbym";
       }
       {
         url = "https://api.pulumi.com/releases/plugins/pulumi-resource-gitlab-v4.6.0-darwin-amd64.tar.gz";
···
         sha256 = "0q19sh7l1mjl40i5vdsrjfldncxnicalmlgv3yjkw5xpxkgr98z0";
       }
       {
-        url = "https://api.pulumi.com/releases/plugins/pulumi-resource-random-v4.4.1-darwin-amd64.tar.gz";
-        sha256 = "13r63s8llr3v1jvl790gcirm0n1m3nhkalrdpm9ssnhyrgfcxpj0";
+        url = "https://api.pulumi.com/releases/plugins/pulumi-resource-random-v4.4.2-darwin-amd64.tar.gz";
+        sha256 = "1wmvmhxnjp32kp43fhjp8w9nrb0biki63w23l4zjxsdk7njply7c";
       }
       {
-        url = "https://api.pulumi.com/releases/plugins/pulumi-resource-snowflake-v0.5.1-darwin-amd64.tar.gz";
-        sha256 = "1wswpqliibq1kr8vv4l6kqw57cbw76nrh4fnvdzvrcl4rhpbjrc8";
+        url = "https://api.pulumi.com/releases/plugins/pulumi-resource-snowflake-v0.5.2-darwin-amd64.tar.gz";
+        sha256 = "0digqqr920g2ahmbiyird7kidnk0j04bbzb9nr2p6lgmdd659ayq";
       }
       {
         url = "https://api.pulumi.com/releases/plugins/pulumi-resource-spotinst-v3.15.0-darwin-amd64.tar.gz";
···
         sha256 = "0y519wmpq6iin20kqidw7b2zkqr6zky09lfsi10klbn0gzfpwbl5";
       }
       {
-        url = "https://api.pulumi.com/releases/plugins/pulumi-resource-aws-v4.38.1-linux-arm64.tar.gz";
-        sha256 = "0wv7c6sp4i64wq5v90k4zpxnzyrhhv34cwa1i4g4pgqfh6ahaz56";
+        url = "https://api.pulumi.com/releases/plugins/pulumi-resource-aws-v5.0.0-linux-arm64.tar.gz";
+        sha256 = "10ch53avymp9j7f41mapl4ffi005vddy8x39ya1kn682i6a0y1ks";
       }
       {
         url = "https://api.pulumi.com/releases/plugins/pulumi-resource-azuread-v5.18.0-linux-arm64.tar.gz";
···
         sha256 = "0qpan6zvny2h2ckigwnf4dhsgmnywam1m4d2jp0nj9pm3628pldv";
       }
       {
-        url = "https://api.pulumi.com/releases/plugins/pulumi-resource-gcp-v6.16.0-linux-arm64.tar.gz";
-        sha256 = "0f8n8q1in0n4z2lzd0y065ksszv05dgn2lgsa8snmxlwfkrx955h";
+        url = "https://api.pulumi.com/releases/plugins/pulumi-resource-gcp-v6.17.0-linux-arm64.tar.gz";
+        sha256 = "01pgzyy70f77cidh228gs72hybwchp65qvs748482wakjcmf44mn";
       }
       {
-        url = "https://api.pulumi.com/releases/plugins/pulumi-resource-github-v4.10.0-linux-arm64.tar.gz";
-        sha256 = "0p8lr9iw1h9ax90aivya513bw1dipm7yycqm5094wgx08r2yfvlm";
+        url = "https://api.pulumi.com/releases/plugins/pulumi-resource-github-v4.10.1-linux-arm64.tar.gz";
+        sha256 = "1lrbl7x7hf1i7xx10cpxz17hihl8b6654wphz8s8g9lp0jryn6am";
       }
       {
         url = "https://api.pulumi.com/releases/plugins/pulumi-resource-gitlab-v4.6.0-linux-arm64.tar.gz";
···
         sha256 = "0j2c23ii4dn9yhpw6nymij65gv82y1xp4gi8lgxxf41b1i9bpb2i";
       }
       {
-        url = "https://api.pulumi.com/releases/plugins/pulumi-resource-random-v4.4.1-linux-arm64.tar.gz";
-        sha256 = "1jac7dj7vsrhcn0fp03bkwmp3km4gxsi9mc5fzjgkmbhh5xnhw3b";
+        url = "https://api.pulumi.com/releases/plugins/pulumi-resource-random-v4.4.2-linux-arm64.tar.gz";
+        sha256 = "1x8v39icapr8iakp9yd50md9dyvj63z7yj93cl3b07qlwr9lcvmv";
       }
       {
-        url = "https://api.pulumi.com/releases/plugins/pulumi-resource-snowflake-v0.5.1-linux-arm64.tar.gz";
-        sha256 = "15cd5g1kdjrfpcsicb4zgwb3q8q2h4xmkwdwbj0m2rys5ygayy2k";
+        url = "https://api.pulumi.com/releases/plugins/pulumi-resource-snowflake-v0.5.2-linux-arm64.tar.gz";
+        sha256 = "0dbqyizvx8gxlidiqc390wjfix1hyikpan32q3hq8d4f8342vjks";
       }
       {
         url = "https://api.pulumi.com/releases/plugins/pulumi-resource-spotinst-v3.15.0-linux-arm64.tar.gz";
···
         sha256 = "174dk82cx35i9x1f1kavydg3qyqax0lhl7637d2n17ca97xa7y8p";
       }
       {
-        url = "https://api.pulumi.com/releases/plugins/pulumi-resource-aws-v4.38.1-darwin-arm64.tar.gz";
-        sha256 = "096xd57z12rabv5375w3nb6zxsnva3nwrvjjxsr4h0sa0yip7sh0";
+        url = "https://api.pulumi.com/releases/plugins/pulumi-resource-aws-v5.0.0-darwin-arm64.tar.gz";
+        sha256 = "0jqbj8fmdmsvr86vy7w6i89jm6pnhs7nchxarsqrlx1lb3qpg2xq";
       }
       {
         url = "https://api.pulumi.com/releases/plugins/pulumi-resource-azuread-v5.18.0-darwin-arm64.tar.gz";
···
         sha256 = "0jj35mj57sivi5qsbwv8qm2jginppi192qlx6ashvgm352gia9r1";
       }
       {
-        url = "https://api.pulumi.com/releases/plugins/pulumi-resource-gcp-v6.16.0-darwin-arm64.tar.gz";
-        sha256 = "16llbsp06pszh4q232ly8nnj1pfr6f4p88a5k928716csh3zradq";
+        url = "https://api.pulumi.com/releases/plugins/pulumi-resource-gcp-v6.17.0-darwin-arm64.tar.gz";
+        sha256 = "06lgq9p5mgqaifl4lrr5csbprx0j3khq93x29j4jvq5kw1qa3gc5";
       }
       {
-        url = "https://api.pulumi.com/releases/plugins/pulumi-resource-github-v4.10.0-darwin-arm64.tar.gz";
-        sha256 = "167f7c7mpyjym0sw71adz5ffd7g8zmn87923xmjlrsz3wm6ybsq7";
+        url = "https://api.pulumi.com/releases/plugins/pulumi-resource-github-v4.10.1-darwin-arm64.tar.gz";
+        sha256 = "1hx8rsf9yysvjg6df8dxzz8kqci000jxzg8wwxjfhcfb9adzjmy8";
       }
       {
         url = "https://api.pulumi.com/releases/plugins/pulumi-resource-gitlab-v4.6.0-darwin-arm64.tar.gz";
···
         sha256 = "1i5ipmidg0yspayxyglbjaihajhj1bsk46saxkncfrkvqnh4iq50";
       }
       {
-        url = "https://api.pulumi.com/releases/plugins/pulumi-resource-random-v4.4.1-darwin-arm64.tar.gz";
-        sha256 = "12zlmihrrcwbmy4q4ysvmz6nys547g914nl8g8vnwviijqlx05df";
+        url = "https://api.pulumi.com/releases/plugins/pulumi-resource-random-v4.4.2-darwin-arm64.tar.gz";
+        sha256 = "1rbig2n5x2lzxpscnja0ya9a68z3jk0qz2zwdnzi66xy7i3zd39l";
       }
       {
-        url = "https://api.pulumi.com/releases/plugins/pulumi-resource-snowflake-v0.5.1-darwin-arm64.tar.gz";
-        sha256 = "0gg80cg2f9d5ah4j7b1i6pxx7ffhbg4pcax319vymcsl9srh51hp";
+        url = "https://api.pulumi.com/releases/plugins/pulumi-resource-snowflake-v0.5.2-darwin-arm64.tar.gz";
+        sha256 = "1r1ln833jfi7hpyfb0cbg8vgam1wghdgr03m75w4hbds5nllw3zm";
       }
       {
         url = "https://api.pulumi.com/releases/plugins/pulumi-resource-spotinst-v3.15.0-darwin-arm64.tar.gz";

pkgs/tools/admin/syft/default.nix

···
 
 buildGoModule rec {
   pname = "syft";
-  version = "0.42.2";
+  version = "0.42.4";
 
   src = fetchFromGitHub {
     owner = "anchore";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-ejyUe2FM8pNQO9esWi9QbSiq6PVEjGbRu+AEnbCFqDE=";
+    sha256 = "sha256-cHjtANCHEuEthfmPmV5MDw4LYY6XI+aux9Gijld7KGc=";
     # populate values that require us to use git. By doing this in postFetch we
     # can delete .git afterwards and maintain better reproducibility of the src.
     leaveDotGit = true;
···
       find "$out" -name .git -print0 | xargs -0 rm -rf
     '';
   };
-  vendorSha256 = "sha256-o5Gq4ZN9H/rXSfIeU2hlExzV5KQZP9DfQsWbOZOB43E=";
+  vendorSha256 = "sha256-+dul6aMsuObmWU8mu+ZnEcWhHo5ClenEDIhKbg3zjB0=";
 
   nativeBuildInputs = [ installShellFiles ];
 

pkgs/tools/audio/tts/default.nix

···
         ''-e 's/${package}.*[<>=]+.*/${package}/g' \''
       ) relaxedConstraints)}
     requirements.txt
+    sed -i '/tensorboardX/d' requirements.txt
   '';
 
   nativeBuildInputs = with python.pkgs; [
···
     pyworld
     scipy
     soundfile
-    tensorboardx
     tensorflow
     torchaudio-bin
     tqdm

pkgs/tools/misc/esphome/default.nix

···
 in
 with python.pkgs; buildPythonApplication rec {
   pname = "esphome";
-  version = "2022.2.6";
+  version = "2022.3.1";
   format = "setuptools";
 
   src = fetchFromGitHub {
     owner = pname;
     repo = pname;
     rev = version;
-    sha256 = "sha256-AoSFtEg7GpUBdIrFCYlOMBRc2nBBtiFEkxoZnKC/xyQ=";
+    sha256 = "sha256-x2gdRUBpyhk6iKvuW6ZKSpokaHfYz1ugclBjP15rJsk=";
   };
 
   postPatch = ''

pkgs/tools/misc/mmctl/default.nix

···
 { lib, fetchFromGitHub, buildGoModule }:
 buildGoModule rec {
   pname = "mmctl";
-  version = "6.3.3";
+  version = "6.4.2";
 
   src = fetchFromGitHub {
     owner = "mattermost";
     repo = "mmctl";
     rev = "v${version}";
-    sha256 = "sha256-V2p6diXymu37aJdHs0ZQJ7ak4LWe55KYCq15JRzMF48=";
+    sha256 = "sha256-FlqkY4LvAW9Cibs+3UkMDWA+uc62wMh13BllWuxjVZU=";
   };
 
   vendorSha256 = null;

pkgs/tools/misc/nix-direnv/default.nix

···
 }:
 stdenv.mkDerivation rec {
   pname = "nix-direnv";
-  version = "1.6.0";
+  version = "1.6.1";
 
   src = fetchFromGitHub {
     owner = "nix-community";
     repo = "nix-direnv";
     rev = version;
-    sha256 = "sha256-vMs4CyMhEy96gWMWXD74rTR1uNjU+y21i0dh6AdaMGE=";
+    sha256 = "sha256-WgNfo9GRqIrXsIgNRhoNPU2/uwyPd8xG8xEEImEy4KY=";
   };
 
   # Substitute instead of wrapping because the resulting file is

pkgs/tools/misc/remind/default.nix

···
 in
 tcl.mkTclDerivation rec {
   pname = "remind";
-  version = "03.04.01";
+  version = "03.04.02";
 
   src = fetchurl {
     url = "https://dianne.skoll.ca/projects/remind/download/remind-${version}.tar.gz";
-    sha256 = "sha256-8INtFmftMb1JSotUdDtMXdSm+UE/8zQW/wIOExr8nkI=";
+    sha256 = "sha256-kjDcO0l39l2KJXo0elZesKZWDZoSoUXIu1Ua7IxWY4w=";
   };
 
   propagatedBuildInputs = tclLibraries;

pkgs/tools/networking/aardvark-dns/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "aardvark-dns";
-  version = "1.0.1";
+  version = "1.0.2";
 
   src = fetchFromGitHub {
     owner = "containers";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-6O/7GoGH0xNbTfIFeD5VLrifNFpHcxxG0bdq/YQb3Ew=";
+    sha256 = "sha256-d4YSCVZkNung4frgAeP46E9Ptpnu9y0HwmPRADo4t0U=";
   };
 
-  cargoHash = "sha256-YdHIyCJ00MKH8PL0osOqQIMwaws3+cOUwvhvA8mOp84=";
-
-  preBuild = ''
-    rm build.rs
-
-    export \
-      VERGEN_BUILD_SEMVER="${version}" \
-      VERGEN_BUILD_TIMESTAMP="$SOURCE_DATE_EPOCH" \
-      VERGEN_GIT_SHA="${src.rev}" \
-      VERGEN_RUSTC_HOST_TRIPLE=""
-  '';
+  cargoHash = "sha256-fu7ZopS55IzzeO7uzLx1wVHQ8A1Ff+9f7FagoZPerxk=";
 
   meta = with lib; {
     description = "Authoritative dns server for A/AAAA container records";

pkgs/tools/networking/drill/default.nix

···
     pkg-config
   ];
 
+  OPENSSL_LIB_DIR = "${openssl.out}/lib";
+  OPENSSL_DIR="${lib.getDev openssl}";
+
   buildInputs = lib.optionals stdenv.isLinux [
     openssl
   ] ++ lib.optionals stdenv.isDarwin [

pkgs/tools/networking/mqttui/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "mqttui";
-  version = "0.16.0";
+  version = "0.16.1";
 
   src = fetchFromGitHub {
     owner = "EdJoPaTo";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-kGOQIoE+0lCBm9zQwPMFfYnLJgR79hSKECerWyOFsjI=";
+    sha256 = "sha256-nLUDuLolv52WJAwBG5gSADWM2LmquJt5jZJioZWX8VA=";
   };
 
-  cargoSha256 = "sha256-vm4IR/yQlQDn9LN9Ifr4vJvM6cCqgjRU2vdAHVEsWnI=";
+  cargoSha256 = "sha256-Z6V7k69fjtiG01s1Xf0UA8lhRsq3T+ImDsCHPSVIDfQ=";
 
   buildInputs = lib.optional stdenv.isDarwin Security;
 

pkgs/tools/networking/netavark/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "netavark";
-  version = "1.0.1";
+  version = "1.0.2";
 
   src = fetchFromGitHub {
     owner = "containers";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-r9NoPDFCqmzESxlovs91j0OyunGDmfWJXN+U1f0w2QQ=";
+    sha256 = "sha256-2ElEhKit/XysRsUw+dg7SnhDl+Zf+FJb5pIYpq1ALNs=";
   };
 
-  cargoHash = "sha256-/N9oKzcAwaxI2BbeoYZ2quN+Z3UO67ecpogK2SRG9Dw=";
-
-  preBuild = ''
-    substituteInPlace Cargo.toml \
-      --replace 'build = "build.rs"' ""
-
-    rm build.rs
-
-    export \
-      VERGEN_BUILD_SEMVER="${version}" \
-      VERGEN_BUILD_TIMESTAMP="$SOURCE_DATE_EPOCH" \
-      VERGEN_GIT_SHA="${src.rev}" \
-      VERGEN_RUSTC_HOST_TRIPLE=""
-  '';
+  cargoHash = "sha256-w3qz4ygjIvn+Rxd1JEVO6Ax08leuuJvC4Bk7VygbBh4=";
 
   nativeBuildInputs = [ installShellFiles mandown ];
 

pkgs/tools/security/authoscope/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "authoscope";
-  version = "0.8.0";
+  version = "0.8.1";
 
   src = fetchFromGitHub {
     owner = "kpcyrd";
     repo = pname;
     rev = "v${version}";
-    sha256 = "11ci38m6d3lj4f0g7cl3dqf10kfk258k2k92phd2nav1my4i90pf";
+    sha256 = "sha256-SKgb/N249s0+Rb59moBT/MeFb4zAAElCMQJto0diyUk=";
   };
 
-  cargoSha256 = "13x7i52i3k88vkfvk2smy2aqfg3na4317scvw7ali1rv545nbxds";
+  cargoSha256 = "sha256-rSHuKy86iJNLAKSVcb7fn7A/cc75EOc97jGI14EaC6k=";
 
   nativeBuildInputs = [
     installShellFiles

pkgs/tools/security/cfripper/default.nix

···
 
 python3.pkgs.buildPythonApplication rec {
   pname = "cfripper";
-  version = "1.6.0";
+  version = "1.7.0";
 
   src = fetchFromGitHub {
     owner = "Skyscanner";
     repo = pname;
     rev = version;
-    hash = "sha256-bomQqg+xzq7+iccE+x6mN265HxkYvy13aAwBBikth3U=";
+    hash = "sha256-bYKusyEItnhj1mU6Tucsdi5pdMoWrUK4Y91SK8dNGE4=";
   };
 
   propagatedBuildInputs = with python3.pkgs; [

pkgs/tools/security/grype/default.nix

···
 
 buildGoModule rec {
   pname = "grype";
-  version = "0.34.6";
+  version = "0.34.7";
 
   src = fetchFromGitHub {
     owner = "anchore";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-3+6ZhAlEOKrgvAXzgOY0q+R/4dbN+qk4Nxuj1IBntzo=";
+    sha256 = "sha256-t95efLTqPnmYiXTBxuxEoDdafoZC/bXXTfKdA8gy3fk=";
     # populate values that require us to use git. By doing this in postFetch we
     # can delete .git afterwards and maintain better reproducibility of the src.
     leaveDotGit = true;
···
     '';
   };
 
-  vendorSha256 = "sha256-u11SKoybGobfxsjLq9mYFzZWw01Dms5RyKxmZA47XqI=";
+  vendorSha256 = "sha256-FZMgS0aNZVq4nvwog4l62dOzC6wW7pQCNbOW1/jssWo=";
 
   nativeBuildInputs = [
     installShellFiles

pkgs/tools/security/sigma-cli/default.nix

···
 
 python3.pkgs.buildPythonApplication rec {
   pname = "sigma-cli";
-  version = "0.3.3";
+  version = "0.3.4";
   format = "pyproject";
 
   src = fetchFromGitHub {
     owner = "SigmaHQ";
     repo = pname;
     rev = "v${version}";
-    hash = "sha256-AUAOZrwLNu+Llg8RX4RKm4vAETgpPLKK1mcpl8jxGYE=";
+    hash = "sha256-FWcPHtEYqS+81dU4lB+4BLFOXtFumcyhucwvmu2TAt8=";
   };
 
   nativeBuildInputs = with python3.pkgs; [

pkgs/tools/security/vault/default.nix

···
 
 buildGoModule rec {
   pname = "vault";
-  version = "1.9.4";
+  version = "1.10.0";
 
   src = fetchFromGitHub {
     owner = "hashicorp";
     repo = "vault";
     rev = "v${version}";
-    sha256 = "sha256-zqtRM2p+RrLrXzDCMtHJZNx/dKWyFqM+3V5eICwWvWs=";
+    sha256 = "sha256-XgrEtAVfMcXbmAjwgIWME/v85QHJ11fUXapAZtS/lSw=";
   };
 
-  vendorSha256 = "sha256-EiQ6XmGrw1O2Zd8TM7HSr3sQUd1naQYKbYLKB/vWdXU=";
+  vendorSha256 = "sha256-Bo0+HSG7NqaweMKPdl+kzB6RdbQsy2FAzmr7ZZVgcsg=";
 
   subPackages = [ "." ];
 
···
     changelog = "https://github.com/hashicorp/vault/blob/v${version}/CHANGELOG.md";
     platforms = platforms.linux ++ platforms.darwin;
     license = licenses.mpl20;
-    maintainers = with maintainers; [ rushmorem lnl7 offline pradeepchhetri Chili-Man ];
+    maintainers = with maintainers; [ rushmorem lnl7 offline pradeepchhetri Chili-Man techknowlogick ];
   };
 }

pkgs/tools/security/vault/update-bin.sh

···
+#!/usr/bin/env nix-shell
+#!nix-shell -i bash -p curl gnused gawk nix-prefetch
+
+set -euo pipefail
+
+ROOT="$(dirname "$(readlink -f "$0")")"
+NIX_DRV="$ROOT/vault-bin.nix"
+if [ ! -f "$NIX_DRV" ]; then
+  echo "ERROR: cannot find vault-bin in $ROOT"
+  exit 1
+fi
+
+fetch_arch() {
+  VER="$1"; ARCH="$2"
+  URL="https://releases.hashicorp.com/vault/${VER}/vault_${VER}_${ARCH}.zip"
+  nix-prefetch "{ stdenv, fetchzip }:
+stdenv.mkDerivation rec {
+  pname = \"vault-bin\"; version = \"${VER}\";
+  src = fetchzip { url = \"$URL\"; };
+}
+"
+}
+
+replace_sha() {
+  sed -i "s#$1 = \"sha256-.\{44\}\"#$1 = \"$2\"#" "$NIX_DRV"
+}
+
+# https://releases.hashicorp.com/vault/1.9.4/vault_1.9.4_linux_arm64.zip
+VAULT_VER=$(curl -Ls -w "%{url_effective}" -o /dev/null https://github.com/hashicorp/vault/releases/latest | awk -F'/' '{print $NF}' | sed 's/v//')
+
+VAULT_LINUX_X86_SHA256=$(fetch_arch "$VAULT_VER" "linux_386")
+VAULT_LINUX_X64_SHA256=$(fetch_arch "$VAULT_VER" "linux_amd64")
+VAULT_DARWIN_X64_SHA256=$(fetch_arch "$VAULT_VER" "darwin_amd64")
+VAULT_LINUX_AARCH64_SHA256=$(fetch_arch "$VAULT_VER" "linux_arm64")
+VAULT_DARWIN_AARCH64_SHA256=$(fetch_arch "$VAULT_VER" "darwin_arm64")
+
+sed -i "s/version = \".*\"/version = \"$VAULT_VER\"/" "$NIX_DRV"
+
+replace_sha "i686-linux" "$VAULT_LINUX_X86_SHA256"
+replace_sha "x86_64-linux" "$VAULT_LINUX_X64_SHA256"
+replace_sha "x86_64-darwin" "$VAULT_DARWIN_X64_SHA256"
+replace_sha "aarch64-linux" "$VAULT_LINUX_AARCH64_SHA256"
+replace_sha "aarch64-darwin" "$VAULT_DARWIN_AARCH64_SHA256"

pkgs/tools/security/vault/vault-bin.nix

···
-{ lib, stdenv, fetchurl, unzip, makeWrapper, gawk, glibc }:
-
-let
-  version = "1.9.1";
-
-  sources = let
-    base = "https://releases.hashicorp.com/vault/${version}";
-  in {
-    x86_64-linux = fetchurl {
-      url = "${base}/vault_${version}_linux_amd64.zip";
-      sha256 = "sha256-kP1wLbkktVCTZopVaT0h/WKqAG3Pd9g7qeruk4MIWJM=";
-    };
-    i686-linux = fetchurl {
-      url = "${base}/vault_${version}_linux_386.zip";
-      sha256 = "sha256-cTZ/hek8wQo9FxIRQ/cc23h7Nqjfonvprf492/lSzLw=";
-    };
-    x86_64-darwin = fetchurl {
-      url = "${base}/vault_${version}_darwin_amd64.zip";
-      sha256 = "sha256-uKW9Yl4PjxWJ886OVAHl1sbPhgYWoL6IJK44vczLQsY=";
-    };
-    aarch64-darwin = fetchurl {
-      url = "${base}/vault_${version}_darwin_arm64.zip";
-      sha256 = "sha256-J0qwUBcnZRZU5TTQB3K8wNE6rdQC1Boy/gKNQRvUYEI=";
-    };
-    aarch64-linux = fetchurl {
-      url = "${base}/vault_${version}_linux_arm64.zip";
-      sha256 = "sha256-eU5s15tBuZFThJGNtnjOV07tiBoVjSSHMS9sY2WqO1o=";
-    };
-  };
+{ lib, stdenv, fetchurl, unzip, makeWrapper, gawk, glibc, fetchzip }:
 
-in stdenv.mkDerivation {
+stdenv.mkDerivation rec {
   pname = "vault-bin";
-  inherit version;
+  version = "1.10.0";
 
-  src = sources.${stdenv.hostPlatform.system} or (throw "unsupported system: ${stdenv.hostPlatform.system}");
-
-  nativeBuildInputs = [ makeWrapper unzip ];
+  src =
+    let
+      inherit (stdenv.hostPlatform) system;
+      selectSystem = attrs: attrs.${system} or (throw "Unsupported system: ${system}");
+      suffix = selectSystem {
+        x86_64-linux = "linux_amd64";
+        aarch64-linux = "linux_arm64";
+        i686-linux = "linux_386";
+        x86_64-darwin = "darwin_amd64";
+        aarch64-darwin = "darwin_arm64";
+      };
+      sha256 = selectSystem {
+        x86_64-linux = "sha256-enD/JcOmeavvUd/njbu7IksAqp9dKepVdYPkLJHA8OQ=";
+        aarch64-linux = "sha256-FDkgUqFEVJoSED/FWqOXa4BTO6AYwkLS2iZh+BkzlqA=";
+        i686-linux = "sha256-XUTWB5Ynu92SMP9Nt/0jAki6til4upKv1sdFzPbWxiw=";
+        x86_64-darwin = "sha256-QNCsbIza56NqSU7R6+Cx//WBXiEOz6CEMCjrx4AR1x8=";
+        aarch64-darwin = "sha256-LBgd8gqeU92336kypSIwMtKo7I1qB/RP2dNoIGJgq7k=";
+      };
+    in
+    fetchzip {
+      url = "https://releases.hashicorp.com/vault/${version}/vault_${version}_${suffix}.zip";
+      inherit sha256;
+    };
 
-  sourceRoot = ".";
+  dontConfigure = true;
+  dontBuild = true;
+  dontStrip = stdenv.isDarwin;
 
   installPhase = ''
     runHook preInstall
-
-    mkdir -p $out/bin $out/share/bash-completion/completions
-    mv vault $out/bin
-    echo "complete -C $out/bin/vault vault" > $out/share/bash-completion/completions/vault
-  '' + lib.optionalString stdenv.isLinux ''
-    wrapProgram $out/bin/vault \
-      --prefix PATH : ${lib.makeBinPath [ gawk glibc ]}
-
+    install -D vault $out/bin/vault
     runHook postInstall
   '';
 
-  dontStrip = stdenv.isDarwin;
+  doInstallCheck = true;
+  installCheckPhase = ''
+    runHook preInstallCheck
+    $out/bin/vault --help
+    $out/bin/vault version
+    runHook postInstallCheck
+  '';
+
+  dontPatchELF = true;
+  dontPatchShebangs = true;
+
+  passthru.updateScript = ./update-bin.sh;
 
   meta = with lib; {
     homepage = "https://www.vaultproject.io";
     description = "A tool for managing secrets, this binary includes the UI";
     platforms = [ "x86_64-linux" "i686-linux" "x86_64-darwin" "aarch64-darwin" "aarch64-linux" ];
     license = licenses.mpl20;
-    maintainers = with maintainers; teams.serokell.members ++ [ offline psyanticy Chili-Man ];
+    maintainers = with maintainers; teams.serokell.members ++ [ offline psyanticy Chili-Man techknowlogick ];
   };
 }

pkgs/tools/system/nats-top/default.nix

···
 
 buildGoModule rec {
   pname = "nats-top";
-  version = "0.4.0";
+  version = "0.5.0";
 
   src = fetchFromGitHub {
     owner = "nats-io";
     repo = pname;
     rev = "v${version}";
-    sha256 = "0b1hpnq8m1xfrn58ammmnx6lmhk319m8z4xjxgckz7wvy2fbzw0n";
+    sha256 = "sha256-IZQDwopFAXPT0V+TTiJk6+j/KhLTA3g4kN1j1PVlNt0=";
   };
 
-  vendorSha256 = "1a48p9gx5zdc340ma6cqakhi6f3lw9b0kz2597j1jcsk2qb7s581";
+  vendorSha256 = "sha256-cBCR/OXUOa+Lh8UvL/VraDAW0hGGwV7teyvdswZQ5Lo=";
 
   meta = with lib; {
     description = "top-like tool for monitoring NATS servers";

pkgs/tools/text/gnused/422.nix

···
-{ lib, stdenv, fetchurl }:
-
-stdenv.mkDerivation rec {
-  pname = "gnused";
-  version = "4.2.2";
-
-  src = fetchurl {
-    url = "mirror://gnu/sed/sed-${version}.tar.bz2";
-    sha256 = "f048d1838da284c8bc9753e4506b85a1e0cc1ea8999d36f6995bcb9460cddbd7";
-  };
-
-  configureFlags = lib.optional stdenv.hostPlatform.isMinGW "ac_cv_func__set_invalid_parameter_handler=no";
-
-  outputs = [ "out" "info" ];
-
-  meta = {
-    homepage = "https://www.gnu.org/software/sed/";
-    description = "GNU sed, a batch stream editor";
-
-    longDescription = ''
-      Sed (stream editor) isn't really a true text editor or text
-      processor.  Instead, it is used to filter text, i.e., it takes
-      text input and performs some operation (or set of operations) on
-      it and outputs the modified text.  Sed is typically used for
-      extracting part of a file using pattern matching or substituting
-      multiple occurrences of a string within a file.
-    '';
-
-    license = lib.licenses.gpl3Plus;
-
-    platforms = lib.platforms.all;
-    maintainers = [ ];
-    mainProgram = "sed";
-  };
-}

pkgs/top-level/all-packages.nix

···
 
   gnu-pw-mgr = callPackage ../tools/security/gnu-pw-mgr { };
 
-  gnused = if !stdenv.hostPlatform.isWindows
-    then callPackage ../tools/text/gnused { } # broken on Windows
-    else gnused_422;
-  # This is an easy work-around for [:space:] problems.
-  gnused_422 = callPackage ../tools/text/gnused/422.nix { };
+  gnused = callPackage ../tools/text/gnused { };
 
   gnutar = callPackage ../tools/archivers/gnutar { };
 
···
 
   optparse-bash = callPackage ../development/libraries/optparse-bash { };
 
+  oras = callPackage ../development/tools/oras { };
+
   orcania = callPackage ../development/libraries/orcania { };
 
   osm-gps-map = callPackage ../development/libraries/osm-gps-map { };
···
   prometheus-nextcloud-exporter = callPackage ../servers/monitoring/prometheus/nextcloud-exporter.nix { };
   prometheus-nginx-exporter = callPackage ../servers/monitoring/prometheus/nginx-exporter.nix { };
   prometheus-nginxlog-exporter = callPackage ../servers/monitoring/prometheus/nginxlog-exporter.nix { };
-  prometheus-node-exporter = callPackage ../servers/monitoring/prometheus/node-exporter.nix { };
+  prometheus-node-exporter = callPackage ../servers/monitoring/prometheus/node-exporter.nix {
+    inherit (darwin.apple_sdk.frameworks) CoreFoundation IOKit;
+  };
   prometheus-openldap-exporter = callPackage ../servers/monitoring/prometheus/openldap-exporter.nix { };
   prometheus-openvpn-exporter = callPackage ../servers/monitoring/prometheus/openvpn-exporter.nix { };
   prometheus-pihole-exporter = callPackage ../servers/monitoring/prometheus/pihole-exporter.nix {  };
···
 
   kubemqctl = callPackage ../applications/networking/cluster/kubemqctl { };
 
+  kubent = callPackage ../applications/networking/cluster/kubent { };
+
   kubeseal = callPackage ../applications/networking/cluster/kubeseal { };
 
   kubernix = callPackage ../applications/networking/cluster/kubernix { };
···
 
   unigine-valley = callPackage ../applications/graphics/unigine-valley { };
 
+  unigine-heaven = callPackage ../applications/graphics/unigine-heaven { };
+
   unipicker = callPackage ../applications/misc/unipicker { };
 
   unison = callPackage ../applications/networking/sync/unison {
···
           loadedTest = if builtins.typeOf test == "path"
             then import test
             else test;
-          calledTest = if lib.isFunction loadedTest
-            then callPackage loadedTest {}
-            else loadedTest;
+          calledTest = lib.toFunction loadedTest pkgs;
         in
           nixosTesting.makeTest calledTest;
 

pkgs/top-level/ocaml-packages.nix

···
 
     magic-mime = callPackage ../development/ocaml-modules/magic-mime { };
 
-    magick = callPackage ../development/ocaml-modules/magick { };
-
     mariadb = callPackage ../development/ocaml-modules/mariadb {
       inherit (pkgs) mariadb;
     };

pkgs/top-level/python-packages.nix

···
     };
 
   pyudev = callPackage ../development/python-modules/pyudev {
-    inherit (pkgs) systemd;
+    inherit (pkgs) udev;
   };
 
   pyunbound = callPackage ../tools/networking/unbound/python.nix { };