Merge staging-next into staging

lib/ascii-table.nix

···
+{ " "  = 32;
+  "!"  = 33;
+  "\"" = 34;
+  "#"  = 35;
+  "$"  = 36;
+  "%"  = 37;
+  "&"  = 38;
+  "'"  = 39;
+  "("  = 40;
+  ")"  = 41;
+  "*"  = 42;
+  "+"  = 43;
+  ","  = 44;
+  "-"  = 45;
+  "."  = 46;
+  "/"  = 47;
+  "0"  = 48;
+  "1"  = 49;
+  "2"  = 50;
+  "3"  = 51;
+  "4"  = 52;
+  "5"  = 53;
+  "6"  = 54;
+  "7"  = 55;
+  "8"  = 56;
+  "9"  = 57;
+  ":"  = 58;
+  ";"  = 59;
+  "<"  = 60;
+  "="  = 61;
+  ">"  = 62;
+  "?"  = 63;
+  "@"  = 64;
+  "A"  = 65;
+  "B"  = 66;
+  "C"  = 67;
+  "D"  = 68;
+  "E"  = 69;
+  "F"  = 70;
+  "G"  = 71;
+  "H"  = 72;
+  "I"  = 73;
+  "J"  = 74;
+  "K"  = 75;
+  "L"  = 76;
+  "M"  = 77;
+  "N"  = 78;
+  "O"  = 79;
+  "P"  = 80;
+  "Q"  = 81;
+  "R"  = 82;
+  "S"  = 83;
+  "T"  = 84;
+  "U"  = 85;
+  "V"  = 86;
+  "W"  = 87;
+  "X"  = 88;
+  "Y"  = 89;
+  "Z"  = 90;
+  "["  = 91;
+  "\\" = 92;
+  "]"  = 93;
+  "^"  = 94;
+  "_"  = 95;
+  "`"  = 96;
+  "a"  = 97;
+  "b"  = 98;
+  "c"  = 99;
+  "d"  = 100;
+  "e"  = 101;
+  "f"  = 102;
+  "g"  = 103;
+  "h"  = 104;
+  "i"  = 105;
+  "j"  = 106;
+  "k"  = 107;
+  "l"  = 108;
+  "m"  = 109;
+  "n"  = 110;
+  "o"  = 111;
+  "p"  = 112;
+  "q"  = 113;
+  "r"  = 114;
+  "s"  = 115;
+  "t"  = 116;
+  "u"  = 117;
+  "v"  = 118;
+  "w"  = 119;
+  "x"  = 120;
+  "y"  = 121;
+  "z"  = 122;
+  "{"  = 123;
+  "|"  = 124;
+  "}"  = 125;
+  "~"  = 126;
+}

lib/strings.nix

···
   */
   makeBinPath = makeSearchPathOutput "bin" "bin";
 
+  /* Normalize path, removing extranous /s
+
+     Type: normalizePath :: string -> string
+
+     Example:
+       normalizePath "/a//b///c/"
+       => "/a/b/c/"
+  */
+  normalizePath = s: (builtins.foldl' (x: y: if y == "/" && hasSuffix "/" x then x else x+y) "" (splitString "" s));
+
   /* Depending on the boolean `cond', return either the given string
      or the empty string. Useful to concatenate against a bigger string.
 
···
       map f (stringToCharacters s)
     );
 
+  /* Convert char to ascii value, must be in printable range
+
+     Type: charToInt :: string -> int
+
+     Example:
+       charToInt "A"
+       => 65
+       charToInt "("
+       => 40
+
+  */
+  charToInt = let
+    table = import ./ascii-table.nix;
+  in c: builtins.getAttr c table;
+
   /* Escape occurrence of the elements of `list` in `string` by
      prefixing it with a backslash.
 
···
        => "\\(foo\\)"
   */
   escape = list: replaceChars list (map (c: "\\${c}") list);
+
+  /* Escape occurence of the element of `list` in `string` by
+     converting to its ASCII value and prefixing it with \\x.
+     Only works for printable ascii characters.
+
+     Type: escapeC = [string] -> string -> string
+
+     Example:
+       escapeC [" "] "foo bar"
+       => "foo\\x20bar"
+
+  */
+  escapeC = list: replaceChars list (map (c: "\\x${ toLower (lib.toHexString (charToInt c))}") list);
 
   /* Quote string to be used safely within the Bourne shell.
 

lib/tests/misc.nix

···
     expected = true;
   };
 
+  testNormalizePath = {
+    expr = strings.normalizePath "//a/b//c////d/";
+    expected = "/a/b/c/d/";
+  };
+
+  testCharToInt = {
+    expr = strings.charToInt "A";
+    expected = 65;
+  };
+
+  testEscapeC = {
+    expr = strings.escapeC [ " " ] "Hello World";
+    expected = "Hello\\x20World";
+  };
+
 # LISTS
 
   testFilter = {

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

···
       </listitem>
       <listitem>
         <para>
+          <link xlink:href="https://ntfy.sh">ntfy.sh</link>, a push
+          notification service. Available as
+          <link linkend="opt-services.ntfy-sh.enable">services.ntfy-sh</link>
+        </para>
+      </listitem>
+      <listitem>
+        <para>
           <link xlink:href="https://git.sr.ht/~migadu/alps">alps</link>,
           a simple and extensible webmail. Available as
           <link linkend="opt-services.alps.enable">services.alps</link>.

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

···
 
 - [Outline](https://www.getoutline.com/), a wiki and knowledge base similar to Notion. Available as [services.outline](#opt-services.outline.enable).
 
+- [ntfy.sh](https://ntfy.sh), a push notification service. Available as [services.ntfy-sh](#opt-services.ntfy-sh.enable)
+
 - [alps](https://git.sr.ht/~migadu/alps), a simple and extensible webmail. Available as [services.alps](#opt-services.alps.enable).
 
 - [endlessh-go](https://github.com/shizunge/endlessh-go), an SSH tarpit that exposes Prometheus metrics. Available as [services.endlessh-go](#opt-services.endlessh-go.enable).

nixos/lib/utils.nix

···
     || hasPrefix a'.mountPoint b'.mountPoint
     || any (hasPrefix a'.mountPoint) b'.depends;
 
-  # Escape a path according to the systemd rules, e.g. /dev/xyzzy
-  # becomes dev-xyzzy.  FIXME: slow.
-  escapeSystemdPath = s:
-   replaceChars ["/" "-" " "] ["-" "\\x2d" "\\x20"]
-   (removePrefix "/" s);
+  # Escape a path according to the systemd rules. FIXME: slow
+  # The rules are described in systemd.unit(5) as follows:
+  # The escaping algorithm operates as follows: given a string, any "/" character is replaced by "-", and all other characters which are not ASCII alphanumerics, ":", "_" or "." are replaced by C-style "\x2d" escapes. In addition, "." is replaced with such a C-style escape when it would appear as the first character in the escaped string.
+  # When the input qualifies as absolute file system path, this algorithm is extended slightly: the path to the root directory "/" is encoded as single dash "-". In addition, any leading, trailing or duplicate "/" characters are removed from the string before transformation. Example: /foo//bar/baz/ becomes "foo-bar-baz".
+  escapeSystemdPath = s: let
+    replacePrefix = p: r: s: (if (hasPrefix p s) then r + (removePrefix p s) else s);
+    trim = s: removeSuffix "/" (removePrefix "/" s);
+    normalizedPath = strings.normalizePath s;
+  in
+    replaceChars ["/"] ["-"]
+    (replacePrefix "." (strings.escapeC ["."] ".")
+    (strings.escapeC (stringToCharacters " !\"#$%&'()*+,;<=>=@[\\]^`{|}~-")
+    (if normalizedPath == "/" then normalizedPath else trim normalizedPath)));
 
   # Quotes an argument for use in Exec* service lines.
   # systemd accepts "-quoted strings with escape sequences, toJSON produces

nixos/modules/module-list.nix

···
   ./services/misc/nix-optimise.nix
   ./services/misc/nix-ssh-serve.nix
   ./services/misc/novacomd.nix
+  ./services/misc/ntfy-sh.nix
   ./services/misc/nzbget.nix
   ./services/misc/nzbhydra2.nix
   ./services/misc/octoprint.nix
···
   ./services/web-apps/calibre-web.nix
   ./services/web-apps/code-server.nix
   ./services/web-apps/baget.nix
+  ./services/web-apps/changedetection-io.nix
   ./services/web-apps/convos.nix
   ./services/web-apps/dex.nix
   ./services/web-apps/discourse.nix

nixos/modules/services/misc/ntfy-sh.nix

···
+{ config, lib, pkgs, ... }:
+
+with lib;
+
+let
+  cfg = config.services.ntfy-sh;
+
+  settingsFormat = pkgs.formats.yaml { };
+in
+
+{
+  options.services.ntfy-sh = {
+    enable = mkEnableOption (mdDoc "[ntfy-sh](https://ntfy.sh), a push notification service");
+
+    package = mkOption {
+      type = types.package;
+      default = pkgs.ntfy-sh;
+      defaultText = literalExpression "pkgs.ntfy-sh";
+      description = mdDoc "The ntfy.sh package to use.";
+    };
+
+    user = mkOption {
+      default = "ntfy-sh";
+      type = types.str;
+      description = lib.mdDoc "User the ntfy-sh server runs under.";
+    };
+
+    group = mkOption {
+      default = "ntfy-sh";
+      type = types.str;
+      description = lib.mdDoc "Primary group of ntfy-sh user.";
+    };
+
+    settings = mkOption {
+      type = types.submodule { freeformType = settingsFormat.type; };
+
+      default = { };
+
+      example = literalExpression ''
+        {
+          listen-http = ":8080";
+        }
+      '';
+
+      description = mdDoc ''
+        Configuration for ntfy.sh, supported values are [here](https://ntfy.sh/docs/config/#config-options).
+      '';
+    };
+  };
+
+  config =
+    let
+      configuration = settingsFormat.generate "server.yml" cfg.settings;
+    in
+    mkIf cfg.enable {
+      # to configure access control via the cli
+      environment = {
+        etc."ntfy/server.yml".source = configuration;
+        systemPackages = [ cfg.package ];
+      };
+
+      systemd.services.ntfy-sh = {
+        description = "Push notifications server";
+
+        wantedBy = [ "multi-user.target" ];
+        after = [ "network.target" ];
+
+        serviceConfig = {
+          ExecStart = "${cfg.package}/bin/ntfy serve -c ${configuration}";
+          User = cfg.user;
+
+          AmbientCapabilities = "CAP_NET_BIND_SERVICE";
+          PrivateTmp = true;
+          NoNewPrivileges = true;
+          CapabilityBoundingSet = "CAP_NET_BIND_SERVICE";
+          ProtectSystem = "full";
+          ProtectKernelTunables = true;
+          ProtectKernelModules = true;
+          ProtectKernelLogs = true;
+          ProtectControlGroups = true;
+          PrivateDevices = true;
+          RestrictSUIDSGID = true;
+          RestrictNamespaces = true;
+          RestrictRealtime = true;
+          MemoryDenyWriteExecute = true;
+        };
+      };
+
+      users.groups = optionalAttrs (cfg.group == "ntfy-sh") {
+        ntfy-sh = { };
+      };
+
+      users.users = optionalAttrs (cfg.user == "ntfy-sh") {
+        ntfy-sh = {
+          isSystemUser = true;
+          group = cfg.group;
+        };
+      };
+    };
+}

nixos/modules/services/web-apps/changedetection-io.nix

···
+{ config, lib, pkgs, ... }:
+
+with lib;
+
+let
+  cfg = config.services.changedetection-io;
+in
+{
+  options.services.changedetection-io = {
+    enable = mkEnableOption (lib.mdDoc "changedetection-io");
+
+    user = mkOption {
+      default = "changedetection-io";
+      type = types.str;
+      description = lib.mdDoc ''
+        User account under which changedetection-io runs.
+      '';
+    };
+
+    group = mkOption {
+      default = "changedetection-io";
+      type = types.str;
+      description = lib.mdDoc ''
+        Group account under which changedetection-io runs.
+      '';
+    };
+
+    listenAddress = mkOption {
+      type = types.str;
+      default = "localhost";
+      description = lib.mdDoc "Address the server will listen on.";
+    };
+
+    port = mkOption {
+      type = types.port;
+      default = 5000;
+      description = lib.mdDoc "Port the server will listen on.";
+    };
+
+    datastorePath = mkOption {
+      type = types.str;
+      default = "/var/lib/changedetection-io";
+      description = lib.mdDoc ''
+        The directory used to store all data for changedetection-io.
+      '';
+    };
+
+    baseURL = mkOption {
+      type = types.nullOr types.str;
+      default = null;
+      example = "https://changedetection-io.example";
+      description = lib.mdDoc ''
+        The base url used in notifications and `{base_url}` token.
+      '';
+    };
+
+    behindProxy = mkOption {
+      type = types.bool;
+      default = false;
+      description = lib.mdDoc ''
+        Enable this option when changedetection-io runs behind a reverse proxy, so that it trusts X-* headers.
+        It is recommend to run changedetection-io behind a TLS reverse proxy.
+      '';
+    };
+
+    environmentFile = mkOption {
+      type = types.nullOr types.path;
+      default = null;
+      example = "/run/secrets/changedetection-io.env";
+      description = lib.mdDoc ''
+        Securely pass environment variabels to changedetection-io.
+
+        This can be used to set for example a frontend password reproducible via `SALTED_PASS`
+        which convinetly also deactivates nags about the hosted version.
+        `SALTED_PASS` should be 64 characters long while the first 32 are the salt and the second the frontend password.
+        It can easily be retrieved from the settings file when first set via the frontend with the following command:
+        ``jq -r .settings.application.password /var/lib/changedetection-io/url-watches.json``
+      '';
+    };
+
+    webDriverSupport = mkOption {
+      type = types.bool;
+      default = false;
+      description = lib.mdDoc ''
+        Enable support for fetching web pages using WebDriver and Chromium.
+        This starts a headless chromium controlled by puppeteer in an oci container.
+
+        ::: {.note}
+        Playwright can currently leak memory.
+        See https://github.com/dgtlmoon/changedetection.io/wiki/Playwright-content-fetcher#playwright-memory-leak
+        :::
+      '';
+    };
+
+    playwrightSupport = mkOption {
+      type = types.bool;
+      default = false;
+      description = lib.mdDoc ''
+        Enable support for fetching web pages using playwright and Chromium.
+        This starts a headless Chromium controlled by puppeteer in an oci container.
+
+        ::: {.note}
+        Playwright can currently leak memory.
+        See https://github.com/dgtlmoon/changedetection.io/wiki/Playwright-content-fetcher#playwright-memory-leak
+        :::
+      '';
+    };
+
+    chromePort = mkOption {
+      type = types.port;
+      default = 4444;
+      description = lib.mdDoc ''
+        A free port on which webDriverSupport or playwrightSupport listen on localhost.
+      '';
+    };
+  };
+
+  config = mkIf cfg.enable {
+    assertions = [
+      {
+        assertion = !((cfg.webDriverSupport == true) && (cfg.playwrightSupport == true));
+        message = "'services.changedetection-io.webDriverSupport' and 'services.changedetion-io.playwrightSupport' cannot be used together.";
+      }
+    ];
+
+    systemd = let
+      defaultStateDir = cfg.datastorePath == "/var/lib/changedetection-io";
+    in {
+      services.changedetection-io = {
+        wantedBy = [ "mutli-user.target" ];
+        after = [ "network.target" ];
+        preStart = ''
+          mkdir -p ${cfg.datastorePath}
+        '';
+        serviceConfig = {
+          User = cfg.user;
+          Group = cfg.group;
+          StateDirectory = mkIf defaultStateDir "changedetion-io";
+          StateDirectoryMode = mkIf defaultStateDir "0750";
+          WorkingDirectory = cfg.datastorePath;
+          Environment = lib.optional (cfg.baseURL != null) "BASE_URL=${cfg.baseURL}"
+            ++ lib.optional cfg.behindProxy "USE_X_SETTINGS=1"
+            ++ lib.optional cfg.webDriverSupport "WEBDRIVER_URL=http://127.0.0.1:${toString cfg.chromePort}/wd/hub"
+            ++ lib.optional cfg.playwrightSupport "PLAYWRIGHT_DRIVER_URL=ws://127.0.0.1:${toString cfg.chromePort}/?stealth=1&--disable-web-security=true";
+          EnvironmentFile = mkIf (cfg.environmentFile != null) cfg.environmentFile;
+          ExecStart = ''
+            ${pkgs.changedetection-io}/bin/changedetection.py \
+              -h ${cfg.listenAddress} -p ${toString cfg.port} -d ${cfg.datastorePath}
+          '';
+          ProtectHome = true;
+          ProtectSystem = true;
+          Restart = "on-failure";
+        };
+      };
+      tmpfiles.rules = mkIf defaultStateDir [
+        "d ${cfg.datastorePath} 0750 ${cfg.user} ${cfg.group} - -"
+      ];
+    };
+
+    users = {
+      users = optionalAttrs (cfg.user == "changedetection-io") {
+        "changedetection-io" = {
+          isSystemUser = true;
+          group = "changedetection-io";
+        };
+      };
+
+      groups = optionalAttrs (cfg.group == "changedetection-io") {
+        "changedetection-io" = { };
+      };
+    };
+
+    virtualisation = {
+      oci-containers.containers = lib.mkMerge [
+        (mkIf cfg.webDriverSupport {
+          changedetection-io-webdriver = {
+            image = "selenium/standalone-chrome";
+            environment = {
+              VNC_NO_PASSWORD = "1";
+              SCREEN_WIDTH = "1920";
+              SCREEN_HEIGHT = "1080";
+              SCREEN_DEPTH = "24";
+            };
+            ports = [
+              "127.0.0.1:${toString cfg.chromePort}:4444"
+            ];
+            volumes = [
+              "/dev/shm:/dev/shm"
+            ];
+            extraOptions = [ "--network=bridge" ];
+          };
+        })
+
+        (mkIf cfg.playwrightSupport {
+          changedetection-io-playwright = {
+            image = "browserless/chrome";
+            environment = {
+              SCREEN_WIDTH = "1920";
+              SCREEN_HEIGHT = "1024";
+              SCREEN_DEPTH = "16";
+              ENABLE_DEBUGGER = "false";
+              PREBOOT_CHROME = "true";
+              CONNECTION_TIMEOUT = "300000";
+              MAX_CONCURRENT_SESSIONS = "10";
+              CHROME_REFRESH_TIME = "600000";
+              DEFAULT_BLOCK_ADS = "true";
+              DEFAULT_STEALTH = "true";
+            };
+            ports = [
+              "127.0.0.1:${toString cfg.chromePort}:3000"
+            ];
+            extraOptions = [ "--network=bridge" ];
+          };
+        })
+      ];
+    };
+  };
+}

nixos/tests/all-tests.nix

···
   novacomd = handleTestOn ["x86_64-linux"] ./novacomd.nix {};
   nscd = handleTest ./nscd.nix {};
   nsd = handleTest ./nsd.nix {};
+  ntfy-sh = handleTest ./ntfy-sh.nix {};
   nzbget = handleTest ./nzbget.nix {};
   nzbhydra2 = handleTest ./nzbhydra2.nix {};
   oh-my-zsh = handleTest ./oh-my-zsh.nix {};

nixos/tests/ntfy-sh.nix

···
+import ./make-test-python.nix {
+
+  nodes.machine = { ... }: {
+    services.ntfy-sh.enable = true;
+  };
+
+  testScript = ''
+    import json
+
+    msg = "Test notification"
+
+    machine.wait_for_unit("multi-user.target")
+
+    machine.succeed(f"curl -d '{msg}' localhost:80/test")
+
+    notif = json.loads(machine.succeed("curl -s localhost:80/test/json?poll=1"))
+
+    assert msg == notif["message"], "Wrong message"
+  '';
+}

pkgs/applications/editors/cudatext/default.nix

···
 in
 stdenv.mkDerivation rec {
   pname = "cudatext";
-  version = "1.173.0";
+  version = "1.173.2";
 
   src = fetchFromGitHub {
     owner = "Alexey-T";
     repo = "CudaText";
     rev = version;
-    hash = "sha256-IMvcGuZotAOdbvMthkmeje3OmToPfPDlx0m87MW3lDE=";
+    hash = "sha256-i/MRBbwy/yJHltGXPjIb89hDXiUzNG6YL83LAAMRwdU=";
   };
 
   postPatch = ''

pkgs/applications/editors/cudatext/deps.json

···
   },
   "ATSynEdit_Cmp": {
     "owner": "Alexey-T",
-    "rev": "2022.10.15",
-    "hash": "sha256-McJTjPMzqtajtfpn01YoeHmZWkmbHxqAy5BmkKID1gE="
+    "rev": "2022.10.18",
+    "hash": "sha256-yaS1XF0v5rkfKj9aksSc4XimKh5wpL7yLt4ElcIKAIE="
   },
   "EControl": {
     "owner": "Alexey-T",

pkgs/applications/editors/vim/plugins/deprecated.json

···
         "new": "vim-gist"
     },
     "lua-dev-nvim": {
-        "date": "2022-10-18",
+        "date": "2022-10-20",
         "new": "neodev-nvim"
     },
     "nvim-bufferline-lua": {

pkgs/applications/editors/vim/plugins/generated.nix

···
 
   SchemaStore-nvim = buildVimPluginFrom2Nix {
     pname = "SchemaStore.nvim";
-    version = "2022-10-17";
+    version = "2022-10-19";
     src = fetchFromGitHub {
       owner = "b0o";
       repo = "SchemaStore.nvim";
-      rev = "b8b7109ee1edbe0d9e573e67eb9f8416f3b1e5ca";
-      sha256 = "0ycfbryjsnl6gzpxkpp96valc875sb2svd9avw8rf96mpfwsij3a";
+      rev = "fe35502e8c05d33bbc359487ee5b9cf7fad2a76a";
+      sha256 = "0w702smq4wa9cgx17mwsj59yl0rr1msppa5d3js0bkj27ij3g33k";
     };
     meta.homepage = "https://github.com/b0o/SchemaStore.nvim/";
   };
···
 
   SpaceVim = buildVimPluginFrom2Nix {
     pname = "SpaceVim";
-    version = "2022-10-19";
+    version = "2022-10-20";
     src = fetchFromGitHub {
       owner = "SpaceVim";
       repo = "SpaceVim";
-      rev = "2b95b6dcdeedc2ddca399f7fef4e3cd8b7c94e3e";
-      sha256 = "01iy43zc974znadbrlvg5zbx5yhy3rd0kymabshxcs10k1lpgmgp";
+      rev = "48c818a86224fd9b061092509db8706b5ae9f6bc";
+      sha256 = "17g4w29vgmgl3l5cwy7m8ylrm79jnz9yrr9rn60wxdf28zrig1gm";
     };
     meta.homepage = "https://github.com/SpaceVim/SpaceVim/";
   };
···
 
   aerial-nvim = buildVimPluginFrom2Nix {
     pname = "aerial.nvim";
-    version = "2022-10-16";
+    version = "2022-10-19";
     src = fetchFromGitHub {
       owner = "stevearc";
       repo = "aerial.nvim";
-      rev = "c2487319c083bc1da3aecf21e054c6cf1bbda9b3";
-      sha256 = "07l7xjzp4pn2lnkrq1rbl89bblf50plpx4wv1r7wli1mfginrkba";
+      rev = "d35799b510f6582f24765dcb8b293fc4988ccc41";
+      sha256 = "19njckq33dsjsr0xh8mq0vzsa25wv57ksykwxiia1afg9qnjvg0l";
     };
     meta.homepage = "https://github.com/stevearc/aerial.nvim/";
   };
···
 
   barbar-nvim = buildVimPluginFrom2Nix {
     pname = "barbar.nvim";
-    version = "2022-10-17";
+    version = "2022-10-20";
     src = fetchFromGitHub {
       owner = "romgrk";
       repo = "barbar.nvim";
-      rev = "f827ad6d48d0278423ee1b45e3f2b94a3ac3d42d";
-      sha256 = "1lwi04ch6d0zfkflal73y1j8g284jxm92ssj91dk3grm4y70y0n4";
+      rev = "68a2751728f9ab3d3510f0fe9165a2a451aa8727";
+      sha256 = "0npwghnll4csngr0ly4wvqbrgmyn1dra138z43nm069w6n157q9g";
     };
     meta.homepage = "https://github.com/romgrk/barbar.nvim/";
   };
···
 
   bufferline-nvim = buildVimPluginFrom2Nix {
     pname = "bufferline.nvim";
-    version = "2022-10-17";
+    version = "2022-10-19";
     src = fetchFromGitHub {
       owner = "akinsho";
       repo = "bufferline.nvim";
-      rev = "0073e32fbf391df5d83c1f4531bb0a41c85e0bec";
-      sha256 = "0fk8v1m36y6mgwc0m8lqz7z0ajcc7pylxapwzhphmmq4qgy0yp4f";
+      rev = "e70be6232f632d16d2412b1faf85554285036278";
+      sha256 = "13bbhhmqnygb92crn3pyrk66nc33sick7x23s8d1ffna7qcqirw6";
     };
     meta.homepage = "https://github.com/akinsho/bufferline.nvim/";
   };
···
 
   ccc-nvim = buildVimPluginFrom2Nix {
     pname = "ccc.nvim";
-    version = "2022-10-18";
+    version = "2022-10-19";
     src = fetchFromGitHub {
       owner = "uga-rosa";
       repo = "ccc.nvim";
-      rev = "316b272cc01d450414651cf070bcc8c6beb0c144";
-      sha256 = "0z7g2bv1yajw8f1gwk3a24k8aczib7fpk3xivw7c6i5kkp4h02cw";
+      rev = "6e526a290877537e29112d511548301b1e1731b2";
+      sha256 = "1mvnpibq844300h7w6z00yjv815q81yj09clxgjdya3zpjm73d9y";
     };
     meta.homepage = "https://github.com/uga-rosa/ccc.nvim/";
   };
···
 
   coc-nvim = buildVimPluginFrom2Nix {
     pname = "coc.nvim";
-    version = "2022-10-18";
+    version = "2022-10-20";
     src = fetchFromGitHub {
       owner = "neoclide";
       repo = "coc.nvim";
-      rev = "b2048d3a5a0195819c406bdbe1af9a7e418c48e4";
-      sha256 = "1zs6zhs0k8kki6jccjqc23yvdnj4gqpwqqk6i9l50b4gwx86zfcd";
+      rev = "853afde8027fda3eb687ea076fa4f5755c68e781";
+      sha256 = "1xgyi751dgjy9x5c1nfn5rcrcxm76f7fbx04qqmrivjjlqpg9a4k";
     };
     meta.homepage = "https://github.com/neoclide/coc.nvim/";
   };
···
 
   coq-artifacts = buildVimPluginFrom2Nix {
     pname = "coq.artifacts";
-    version = "2022-10-19";
+    version = "2022-10-20";
     src = fetchFromGitHub {
       owner = "ms-jpq";
       repo = "coq.artifacts";
-      rev = "e45bdaa4bd5d2348a64c51596b91ab58b58bc2cf";
-      sha256 = "0033d4z0sjm4397wna1yb87vjm0gmjwr4b46pxv69zjikb38mxw3";
+      rev = "7d3a56b9eaaa99c8c73d4838630f46e81a016362";
+      sha256 = "0kxv53wnjxms3pn0dwg2z36f1lraw0fgxax4lb5i52mhwn7vg2qg";
     };
     meta.homepage = "https://github.com/ms-jpq/coq.artifacts/";
   };
 
   coq-thirdparty = buildVimPluginFrom2Nix {
     pname = "coq.thirdparty";
-    version = "2022-10-19";
+    version = "2022-10-20";
     src = fetchFromGitHub {
       owner = "ms-jpq";
       repo = "coq.thirdparty";
-      rev = "86ad87b631b207fa34e088fec3e8935a3e2c9120";
-      sha256 = "0qspw4as1fc0w3w7vr5hsw4p7rlcls9md653w68qxsbdyyhid69q";
+      rev = "5cbf8a2b67246dca9611b19000df9d1d04922cab";
+      sha256 = "1j0bja06gpnyqh0qb6kq1grmf0dr8p4k63w1rxjynj1fnnvp3vcs";
     };
     meta.homepage = "https://github.com/ms-jpq/coq.thirdparty/";
   };
···
 
   coq_nvim = buildVimPluginFrom2Nix {
     pname = "coq_nvim";
-    version = "2022-10-19";
+    version = "2022-10-20";
     src = fetchFromGitHub {
       owner = "ms-jpq";
       repo = "coq_nvim";
-      rev = "5d3d020720f49cf86c52a1bf2d132a37e07ad6b1";
-      sha256 = "0a0g1qi412cprj9gggiwaf43ld2s87m2c5wk5gpfk4y6zj8pawb1";
+      rev = "1a07d8454d620b386ed9c04c41097862b0d0ace4";
+      sha256 = "13maibc8vdd5gs194dmh2jdynjv4xryr6wjavryq2bfzh5kx6xx8";
     };
     meta.homepage = "https://github.com/ms-jpq/coq_nvim/";
   };
···
 
   fzf-lua = buildVimPluginFrom2Nix {
     pname = "fzf-lua";
-    version = "2022-10-18";
+    version = "2022-10-19";
     src = fetchFromGitHub {
       owner = "ibhagwan";
       repo = "fzf-lua";
-      rev = "5427104f8b7a7b24ea4a66d1d661b0560b159d99";
-      sha256 = "1wvvq5assplm4bbgpjv0q077b00rxvcajbd28r67b96zwsk0bp54";
+      rev = "5eeacc2f6646a2b51f99cb321c4d1e6c48abf22f";
+      sha256 = "0gp23r9kfnakcb4rxks9xx8dfiphgwwx34vccbmx51d490yb4b50";
     };
     meta.homepage = "https://github.com/ibhagwan/fzf-lua/";
   };
···
 
   julia-vim = buildVimPluginFrom2Nix {
     pname = "julia-vim";
-    version = "2022-09-11";
+    version = "2022-10-20";
     src = fetchFromGitHub {
       owner = "JuliaEditorSupport";
       repo = "julia-vim";
-      rev = "08e9a478877517b1f712e2a3f26b9d09552ef55d";
-      sha256 = "1yrzrdxx1ysx2yqxqkhkxk6vs1irir4r8bkhfdqj0h381fgbysyf";
+      rev = "fca7e3e59e6f9417d3fd77bac50d4b820a3e8bc4";
+      sha256 = "1pby3mx29wh5a0d4zdslkf43prm4f2w1an4qsyfhw2gn7kwmi2lj";
     };
     meta.homepage = "https://github.com/JuliaEditorSupport/julia-vim/";
   };
 
   kanagawa-nvim = buildVimPluginFrom2Nix {
     pname = "kanagawa.nvim";
-    version = "2022-10-18";
+    version = "2022-10-19";
     src = fetchFromGitHub {
       owner = "rebelot";
       repo = "kanagawa.nvim";
-      rev = "6f692e38ef2852ac146124ff9bcd28b8d8c1b1de";
-      sha256 = "1lhz3x4mwwiz36hkxf8gv782j8218zfq86pav72dryvsjrfxyblc";
+      rev = "a6f8ea10900e8d891f9c93e0ed258f118010fb24";
+      sha256 = "085xazb21c27zj5zv5vynmj4mv6zda1xf8d4icfpw41z68p4c1la";
     };
     meta.homepage = "https://github.com/rebelot/kanagawa.nvim/";
   };
···
 
   lazy-lsp-nvim = buildVimPluginFrom2Nix {
     pname = "lazy-lsp.nvim";
-    version = "2022-10-10";
+    version = "2022-10-20";
     src = fetchFromGitHub {
       owner = "dundalek";
       repo = "lazy-lsp.nvim";
-      rev = "c405a63b2424fec42bb67da53fc06b4a82a56963";
-      sha256 = "12b1pr23hl1avw4i44r47zkrw1h61qwz305l7gsngj3p69z4722r";
+      rev = "20f66b6a1ce6b22b3c02d0f53c15dfa7c6a9f3c8";
+      sha256 = "1yigp01qk2ljzb5sskgqic7igxwa4q8rkg4ga9czb3w4f84kpb09";
     };
     meta.homepage = "https://github.com/dundalek/lazy-lsp.nvim/";
   };
···
     meta.homepage = "https://github.com/kkharji/lspsaga.nvim/";
   };
 
-  lua-dev-nvim = buildVimPluginFrom2Nix {
-    pname = "lua-dev.nvim";
-    version = "2022-10-19";
-    src = fetchFromGitHub {
-      owner = "folke";
-      repo = "neodev.nvim";
-      rev = "dbd7bc1da13522eaad4022325f578c8c2d94d9a1";
-      sha256 = "101h55bal3bd25n8fjkz7djz1as1i94glcpikgjw94hcv95hvwk2";
-    };
-    meta.homepage = "https://github.com/folke/neodev.nvim/";
-  };
-
   lualine-lsp-progress = buildVimPluginFrom2Nix {
     pname = "lualine-lsp-progress";
     version = "2021-10-23";
···
 
   lualine-nvim = buildVimPluginFrom2Nix {
     pname = "lualine.nvim";
-    version = "2022-10-06";
+    version = "2022-10-19";
     src = fetchFromGitHub {
       owner = "nvim-lualine";
       repo = "lualine.nvim";
-      rev = "edca2b03c724f22bdc310eee1587b1523f31ec7c";
-      sha256 = "06gy6jy3gfhhjcy61fx9myhs4bmknhlfsmnsi1mmcydhm4gcbm2b";
+      rev = "abb03129e0b0b7f4c992b1b4c98245cd4422e7d5";
+      sha256 = "1lwwhiwqv5f1i0v6a6g6zbmj5pfs5ya3mnxn3d36q8zf4ssz8xfh";
     };
     meta.homepage = "https://github.com/nvim-lualine/lualine.nvim/";
   };
···
 
   material-nvim = buildVimPluginFrom2Nix {
     pname = "material.nvim";
-    version = "2022-10-19";
+    version = "2022-10-20";
     src = fetchFromGitHub {
       owner = "marko-cerovac";
       repo = "material.nvim";
-      rev = "e2bd86883263c1b009daf1fef1f5f2b2ea42024e";
-      sha256 = "1l9a2557ykdqngzwq7jqff2kp9apd0aqzq124675acjwcc1wam1h";
+      rev = "7fca639bd8e3c775be885383002cf8ebdc93a6f7";
+      sha256 = "17ih1lsxpalpj63gp2mdgwnzrvayqxn8s52wn1m4s92d0fs8pn3j";
     };
     meta.homepage = "https://github.com/marko-cerovac/material.nvim/";
   };
···
     meta.homepage = "https://github.com/KeitaNakamura/neodark.vim/";
   };
 
+  neodev-nvim = buildVimPluginFrom2Nix {
+    pname = "neodev.nvim";
+    version = "2022-10-20";
+    src = fetchFromGitHub {
+      owner = "folke";
+      repo = "neodev.nvim";
+      rev = "218d9b06f6b91a0d5b9d8d9c165c5c286f9521ea";
+      sha256 = "0m88ykblj7nssw7l6492h742zl8cm0mhv23sb1nj73m5x95h4d4c";
+    };
+    meta.homepage = "https://github.com/folke/neodev.nvim/";
+  };
+
   neoformat = buildVimPluginFrom2Nix {
     pname = "neoformat";
     version = "2022-09-01";
···
 
   nightfox-nvim = buildVimPluginFrom2Nix {
     pname = "nightfox.nvim";
-    version = "2022-10-15";
+    version = "2022-10-20";
     src = fetchFromGitHub {
       owner = "EdenEast";
       repo = "nightfox.nvim";
-      rev = "15f3b5837a8d07f45cbe16753fbf13630bc167a3";
-      sha256 = "08zjhp1199yq5byrgksgaw55p3q74xr5j4ja24af08x8ifkr3bsj";
+      rev = "2ae719a01b80ca0629d5983aa9b23e7daf00744b";
+      sha256 = "1ph52n0y0pzb32wnzjg753wm8v5nj0l2wy00f6pyad9im2fmarqj";
     };
     meta.homepage = "https://github.com/EdenEast/nightfox.nvim/";
   };
···
 
   noice-nvim = buildVimPluginFrom2Nix {
     pname = "noice.nvim";
-    version = "2022-10-18";
+    version = "2022-10-20";
     src = fetchFromGitHub {
       owner = "folke";
       repo = "noice.nvim";
-      rev = "57d68bff549860b30f22bd2e77b68f68593ad162";
-      sha256 = "1yq5lp0z9qll9rzjy7a5wa94iyxn53yk10ibxpikqi52q158267x";
+      rev = "b10055a599af8d86ea0ae75bc2abb953ba20acbc";
+      sha256 = "15c0jcyhklrf4h4mid1a3049257rkvlbsbabrcfk10g0kad71kai";
     };
     meta.homepage = "https://github.com/folke/noice.nvim/";
   };
···
 
   nordic-nvim = buildVimPluginFrom2Nix {
     pname = "nordic.nvim";
-    version = "2022-10-17";
+    version = "2022-10-20";
     src = fetchFromGitHub {
       owner = "andersevenrud";
       repo = "nordic.nvim";
-      rev = "f9c9a672aea76da324eaa1b3c7f5dc8a3baf174e";
-      sha256 = "1i1wi7hp94wc04z9khsvriahdnmbslvnyn2035p4qf4jlbpwfvrg";
+      rev = "1d6602e05fa0bc256979a5af6f1a3bc4a13d64a9";
+      sha256 = "0iz0x03685vps5ns6hws1ym727s1c5535q8v21nkxzzm4qbwhi8j";
     };
     meta.homepage = "https://github.com/andersevenrud/nordic.nvim/";
   };
···
 
   nui-nvim = buildVimPluginFrom2Nix {
     pname = "nui.nvim";
-    version = "2022-10-15";
+    version = "2022-10-19";
     src = fetchFromGitHub {
       owner = "MunifTanjim";
       repo = "nui.nvim";
-      rev = "c59bdcfde011b88bfb71b5c4351684cf67bf5f9f";
-      sha256 = "0y8n8qpy3swvmd29cs4yf3krkjhlx324ncya0hzciqk5j9j3j9vh";
+      rev = "35758e946a64376e0e9625a27469410b3d1f9223";
+      sha256 = "03clg9m0rzqx8nmjk4brix21mrkr9n7229834d942gb3hssaxni0";
     };
     meta.homepage = "https://github.com/MunifTanjim/nui.nvim/";
   };
 
   null-ls-nvim = buildVimPluginFrom2Nix {
     pname = "null-ls.nvim";
-    version = "2022-10-13";
+    version = "2022-10-20";
     src = fetchFromGitHub {
       owner = "jose-elias-alvarez";
       repo = "null-ls.nvim";
-      rev = "643c67a296711ff40f1a4d1bec232fa20b179b90";
-      sha256 = "0wvbh0avz80g29ph52aqkxgnkykg58x5jcvn57zb0rb7dbbpcf56";
+      rev = "24463756e80ce381f530c02debe781f3c7ba7599";
+      sha256 = "07297dpachnvjpn9fff5yrbavaayxpgfwc0qyfi0na2ghylkhqn4";
     };
     meta.homepage = "https://github.com/jose-elias-alvarez/null-ls.nvim/";
   };
···
 
   nvim-base16 = buildVimPluginFrom2Nix {
     pname = "nvim-base16";
-    version = "2022-08-28";
+    version = "2022-10-19";
     src = fetchFromGitHub {
       owner = "RRethy";
       repo = "nvim-base16";
-      rev = "d2a56671ed19fb471acf0c39af261568ea47ee26";
-      sha256 = "1w4d0z06zzzjlksr6amdjqwb0lgvpidx3xi93n08yjbhzq0c0plw";
+      rev = "52e077ffadf3c03d2186515091fa9a88a1f950ac";
+      sha256 = "198hfiksp29pdqwklkbc5zp63wnvwz7d39vxpklywyvy1wdf6l1b";
     };
     meta.homepage = "https://github.com/RRethy/nvim-base16/";
   };
···
 
   nvim-dap = buildVimPluginFrom2Nix {
     pname = "nvim-dap";
-    version = "2022-10-14";
+    version = "2022-10-19";
     src = fetchFromGitHub {
       owner = "mfussenegger";
       repo = "nvim-dap";
-      rev = "e71da68e59eec1df258acac20dad206366506438";
-      sha256 = "10vs85nmh3kk549p72mp712h4y8vyjhhkpi2ni2m6hlgld17zsyw";
+      rev = "3d0d7312bb2a8491eb2927504e5cfa6e81b66de4";
+      sha256 = "0apzpy1mchk6iz6gxx218l2cb7rkjwviil56ab9ndk5jdd1irjag";
     };
     meta.homepage = "https://github.com/mfussenegger/nvim-dap/";
   };
···
 
   nvim-dap-ui = buildVimPluginFrom2Nix {
     pname = "nvim-dap-ui";
-    version = "2022-10-06";
+    version = "2022-10-20";
     src = fetchFromGitHub {
       owner = "rcarriga";
       repo = "nvim-dap-ui";
-      rev = "1cd4764221c91686dcf4d6b62d7a7b2d112e0b13";
-      sha256 = "19fn9jghvjvmvfm06g2a1hbpm1yd9w5dnr5dcqpwcaz0pxi1y74x";
+      rev = "0a63115d72e071223e1711ce630e9e7b5737c948";
+      sha256 = "1swwyf498g69mm47whdyka7250pqg630fnhwkg0bzslv9ph891rg";
     };
     meta.homepage = "https://github.com/rcarriga/nvim-dap-ui/";
   };
···
 
   nvim-jdtls = buildVimPluginFrom2Nix {
     pname = "nvim-jdtls";
-    version = "2022-10-15";
+    version = "2022-10-19";
     src = fetchFromGitHub {
       owner = "mfussenegger";
       repo = "nvim-jdtls";
-      rev = "faf7ec2df507e16082afc4ef6b18813863f68dd8";
-      sha256 = "01sp8pgrqwdlzqkzdjbjmwp204hg3dil0yv21785dd4v68sa4h3c";
+      rev = "a59ab0202810c7230d54725535c3ca5dfe5bcbfc";
+      sha256 = "0dacpcmvsqsxdm0w2x30yxhlkqmng3nal8adva9sbmqywann6cxq";
     };
     meta.homepage = "https://github.com/mfussenegger/nvim-jdtls/";
   };
···
 
   nvim-lspconfig = buildVimPluginFrom2Nix {
     pname = "nvim-lspconfig";
-    version = "2022-10-17";
+    version = "2022-10-20";
     src = fetchFromGitHub {
       owner = "neovim";
       repo = "nvim-lspconfig";
-      rev = "2dd9e060f21eecd403736bef07ec83b73341d955";
-      sha256 = "1waw76d45n78sfxnmhnmcbzgzgv8mydsh2xqkzn5igcndx53h5mb";
+      rev = "3592f769f2d6b07ce3083744cd0a13442f5d4f43";
+      sha256 = "1sbk30f3ajpks6wxyj1gh9b11si59hmffn12wd7a00zvgbgqa4vr";
     };
     meta.homepage = "https://github.com/neovim/nvim-lspconfig/";
   };
···
 
   nvim-metals = buildVimPluginFrom2Nix {
     pname = "nvim-metals";
-    version = "2022-10-18";
+    version = "2022-10-20";
     src = fetchFromGitHub {
       owner = "scalameta";
       repo = "nvim-metals";
-      rev = "8f838ebbdc4e3078e178f1cf0474858a014f490e";
-      sha256 = "008kjzyb0nj2g1kmpir6ayxpmy7cpprhidzzsqyqra4kgsicbscd";
+      rev = "f2893fb6e3f089131fc8f7b45eb4eb86682034f4";
+      sha256 = "142rmhbqzjwg13zn9z50w92avq2gkylf7prcc35xf5rs9mc3kh0l";
     };
     meta.homepage = "https://github.com/scalameta/nvim-metals/";
   };
···
 
   nvim-snippy = buildVimPluginFrom2Nix {
     pname = "nvim-snippy";
-    version = "2022-10-15";
+    version = "2022-10-19";
     src = fetchFromGitHub {
       owner = "dcampos";
       repo = "nvim-snippy";
-      rev = "88bb84058c24f4ffe5ffecae9ca2dcb36a5dba4c";
-      sha256 = "1bi0hhl59xvmgbi8pcn6jp37p8665h3w8kx1if8dr2rjijrf6ay1";
+      rev = "d732f34c2c64baff182f9d9dc2463490fc3c7f91";
+      sha256 = "0a7g9s9c8wxk955qj0yvmmwzrv37x8wkn8c07arvp2xj77hpb6rc";
     };
     meta.homepage = "https://github.com/dcampos/nvim-snippy/";
   };
···
 
   nvim-spectre = buildVimPluginFrom2Nix {
     pname = "nvim-spectre";
-    version = "2022-09-27";
+    version = "2022-10-20";
     src = fetchFromGitHub {
       owner = "nvim-pack";
       repo = "nvim-spectre";
-      rev = "6d877bc1f2262af1053da466e4acd909ad61bc18";
-      sha256 = "01cnc7wcm5qi2zm63v4hkzng6fm4945cw7r2n21gn914snypfxgg";
+      rev = "e27cf9f4506e39ba11a162c6c4aa8e5ff8f296f1";
+      sha256 = "0f3sy23jac31fgrcbphhdkl6y8iwi79i9c8yi8gsz3m6a3czhkpw";
     };
     meta.homepage = "https://github.com/nvim-pack/nvim-spectre/";
   };
···
 
   nvim-treesitter = buildVimPluginFrom2Nix {
     pname = "nvim-treesitter";
-    version = "2022-10-18";
+    version = "2022-10-20";
     src = fetchFromGitHub {
       owner = "nvim-treesitter";
       repo = "nvim-treesitter";
-      rev = "e06da64459e97ccbbf08a5a9e86d21a3663592be";
-      sha256 = "0swfiwpk3fq5f3r7dfw8wy3pp1nqk4xc48g6jsv5p43am6nzkdz3";
+      rev = "d49495fe72cbcedc944eece3611005dc0fa6acda";
+      sha256 = "1ngh7dlgppicdf5f5zs26wpyc2h0pqkqmgkhq288j7ic9lpw4z5x";
     };
     meta.homepage = "https://github.com/nvim-treesitter/nvim-treesitter/";
   };
···
 
   onedark-nvim = buildVimPluginFrom2Nix {
     pname = "onedark.nvim";
-    version = "2022-10-18";
+    version = "2022-10-19";
     src = fetchFromGitHub {
       owner = "navarasu";
       repo = "onedark.nvim";
-      rev = "64fc4bc348e52e8e578beca26021d47c4d272a2a";
-      sha256 = "1b4rwap0dva67xg2vf2dj35522wjkfm061bpa6inbyg9waidf480";
+      rev = "fdfe7bfff486acd102aae7fb2ff52e7e5f6c2bad";
+      sha256 = "0z9kagqv196v0gcgm9zl1fp61j01msl4d00lndnlwnlggn2xcbf7";
     };
     meta.homepage = "https://github.com/navarasu/onedark.nvim/";
   };
···
 
   onedarkpro-nvim = buildVimPluginFrom2Nix {
     pname = "onedarkpro.nvim";
-    version = "2022-10-18";
+    version = "2022-10-19";
     src = fetchFromGitHub {
       owner = "olimorris";
       repo = "onedarkpro.nvim";
-      rev = "55b2a219fd56f1984abf4c64913f32e89c80d890";
-      sha256 = "10lqlpcxgj8bxqh8hzqd8qzrphlai88zmi7ra6970lwg3g0y5484";
+      rev = "050e23fa587ee959387fe8d67711f189caa5704b";
+      sha256 = "0l7xb55r7jya594c06jswbvqk06cma2b50zhl0vw57fagir2258m";
     };
     meta.homepage = "https://github.com/olimorris/onedarkpro.nvim/";
   };
···
 
   onenord-nvim = buildVimPluginFrom2Nix {
     pname = "onenord.nvim";
-    version = "2022-10-18";
+    version = "2022-10-19";
     src = fetchFromGitHub {
       owner = "rmehri01";
       repo = "onenord.nvim";
-      rev = "98c64654375bc087e96bca08fd194066d778717c";
-      sha256 = "1k49wjlxbh2dsbmmp15www2fny9xjnq7z9ic95rfb8c9r6aipqx9";
+      rev = "1d4c13a7fb6480e4dd508cda8207732f18d419bf";
+      sha256 = "0l65mnshc6hmsarbr002z06k7c88aqyl0d4s9qqwdchlbi7h11dj";
     };
     meta.homepage = "https://github.com/rmehri01/onenord.nvim/";
   };
···
 
   telescope-coc-nvim = buildVimPluginFrom2Nix {
     pname = "telescope-coc.nvim";
-    version = "2022-10-10";
+    version = "2022-10-20";
     src = fetchFromGitHub {
       owner = "fannheyward";
       repo = "telescope-coc.nvim";
-      rev = "da487dfd41266a0b5507a310da684ef3a3bfdb68";
-      sha256 = "1lnang3qn861z0p657aa8r7w6d1v6qn86gdwg7di11dgc5vljfh4";
+      rev = "0193fe529edd2cb61ccc020b492df76528f880fc";
+      sha256 = "1y7kav5749bznz5m7102igba29yvfbasnbn6hzsx57g8vj36kwbb";
     };
     meta.homepage = "https://github.com/fannheyward/telescope-coc.nvim/";
   };
···
 
   tokyonight-nvim = buildVimPluginFrom2Nix {
     pname = "tokyonight.nvim";
-    version = "2022-10-18";
+    version = "2022-10-20";
     src = fetchFromGitHub {
       owner = "folke";
       repo = "tokyonight.nvim";
-      rev = "2a2ce9bdb76d7a2104bbfa5cfbcadcd15de0d7e9";
-      sha256 = "0mxd15x2scx4a6w3vwdsx6h5zhlipi4ycckidv6ipqibf8k1gcf6";
+      rev = "9a0843ba36ff9720198ca15ac2351c40186543ab";
+      sha256 = "0srzfqwpfqs0iyhm10xfyrfx0zwj78kzqbhc12gkm1fp6nmh8n2g";
     };
     meta.homepage = "https://github.com/folke/tokyonight.nvim/";
   };
···
 
   vim-lsp = buildVimPluginFrom2Nix {
     pname = "vim-lsp";
-    version = "2022-10-17";
+    version = "2022-10-19";
     src = fetchFromGitHub {
       owner = "prabirshrestha";
       repo = "vim-lsp";
-      rev = "2bb97d29382dea308d6887f493148d70a48c5ab1";
-      sha256 = "1cnr228iyh3p46bnk095shmhmljbazybabvbqrg214a0i9zwsamy";
+      rev = "a85b71bfc862753ee11ae5986d882bd9588b17a2";
+      sha256 = "00ll4lk9x0aail43dzlls70w53zggjz2am9kkn31cwhn4v5g9gng";
     };
     meta.homepage = "https://github.com/prabirshrestha/vim-lsp/";
   };
···
 
   vim-prosession = buildVimPluginFrom2Nix {
     pname = "vim-prosession";
-    version = "2022-10-14";
+    version = "2022-10-20";
     src = fetchFromGitHub {
       owner = "dhruvasagar";
       repo = "vim-prosession";
-      rev = "7a3985a39cc5a63f037f64a20a15175310826b7e";
-      sha256 = "1inal1wmin8fia4b5h3ppyqsvakhhwgdg1y1p6hd0c29c954q0w2";
+      rev = "249b635d7483c8e1f8fcdcc50e1457b65a2bbf29";
+      sha256 = "07hyjp5y6sn4pdlc643251y5yqz6c0pqrd3vybfm4jhcy4zkvj89";
     };
     meta.homepage = "https://github.com/dhruvasagar/vim-prosession/";
   };
···
 
   vim-table-mode = buildVimPluginFrom2Nix {
     pname = "vim-table-mode";
-    version = "2022-05-28";
+    version = "2022-10-20";
     src = fetchFromGitHub {
       owner = "dhruvasagar";
       repo = "vim-table-mode";
-      rev = "f47287df379bd5599ab5f118ed9b71c61097b516";
-      sha256 = "07xiln2qdb4ldplyx4schc0z1bw24zdnyfk1y03yjfx29rs0yxj4";
+      rev = "9555a3e6e5bcf285ec181b7fc983eea90500feb4";
+      sha256 = "0pzqk8h3h4z4dbgaxla76wlc1fzxk9cbw3xcwjpjgvbgxplg565s";
     };
     meta.homepage = "https://github.com/dhruvasagar/vim-table-mode/";
   };
···
 
   vim-vsnip-integ = buildVimPluginFrom2Nix {
     pname = "vim-vsnip-integ";
-    version = "2022-04-18";
+    version = "2022-10-20";
     src = fetchFromGitHub {
       owner = "hrsh7th";
       repo = "vim-vsnip-integ";
-      rev = "64c2ed66406c58163cf81fb5e13ac2f9fcdfb52b";
-      sha256 = "0r4kxw112rxc7sz5dzcginbv5ak1as4ky40db2r5wdg5nm08c4z8";
+      rev = "4be94fb2a0d51b2fdf1a508d31cf62b3bff48e6d";
+      sha256 = "0gza8nxzs6qc2w66fa1rjsgrhkmgllfflnf1jhrqn5rsdcq7fs0y";
     };
     meta.homepage = "https://github.com/hrsh7th/vim-vsnip-integ/";
   };
···
 
   catppuccin-nvim = buildVimPluginFrom2Nix {
     pname = "catppuccin-nvim";
-    version = "2022-10-14";
+    version = "2022-10-20";
     src = fetchFromGitHub {
       owner = "catppuccin";
       repo = "nvim";
-      rev = "d5f8176232d91c50265f01674d99bf0ab4e79273";
-      sha256 = "1i00c70rq62m9dnh4pg7xc852hapl0f162rr255i79amrp7fsvfy";
+      rev = "56604126c671aac3bebd6a33c9d1c55ac9359ce1";
+      sha256 = "0czkqads8i9m0vc2np55glay0s6ii1y6nbb07sr9ck356qj6ix40";
     };
     meta.homepage = "https://github.com/catppuccin/nvim/";
   };
···
 
   chad = buildVimPluginFrom2Nix {
     pname = "chad";
-    version = "2022-10-19";
+    version = "2022-10-20";
     src = fetchFromGitHub {
       owner = "ms-jpq";
       repo = "chadtree";
-      rev = "0fca048835601f00f3fa9c8566de304350edf4ea";
-      sha256 = "01jfq0cr7agp98adsyi4i0hmawz9v5g0n7xrlxqv88jvjawws637";
+      rev = "d028cffc3dfb9f78187c6bb3c57013af3e8ab081";
+      sha256 = "0l9x1kvjbsg6c2d9ww6hmf0qz8v5r34g80agqw8is5nvmbsqfa8j";
     };
     meta.homepage = "https://github.com/ms-jpq/chadtree/";
   };

pkgs/applications/editors/vim/plugins/vim-plugin-names

···
 https://github.com/lspcontainers/lspcontainers.nvim/,,
 https://github.com/onsails/lspkind-nvim/,,
 https://github.com/tami5/lspsaga.nvim/,,
-https://github.com/folke/lua-dev.nvim/,,
 https://github.com/arkav/lualine-lsp-progress/,,
 https://github.com/nvim-lualine/lualine.nvim/,,
 https://github.com/l3mon4d3/luasnip/,,
···
 https://github.com/Shougo/neco-vim/,,
 https://github.com/Shougo/neocomplete.vim/,,
 https://github.com/KeitaNakamura/neodark.vim/,,
+https://github.com/folke/neodev.nvim/,HEAD,
 https://github.com/sbdchd/neoformat/,,
 https://github.com/TimUntersberger/neogit/,,
 https://github.com/Shougo/neoinclude.vim/,,

pkgs/applications/editors/vscode/extensions/default.nix

···
         };
       };
 
+      sumneko.lua = callPackage ./lua { };
+
       svelte.svelte-vscode = buildVscodeMarketplaceExtension {
         mktplcRef = {
           name = "svelte-vscode";

pkgs/applications/editors/vscode/extensions/lua/default.nix

···
+{ lib
+, vscode-utils
+, sumneko-lua-language-server
+}:
+
+vscode-utils.buildVscodeMarketplaceExtension {
+  mktplcRef = {
+    name = "lua";
+    publisher = "sumneko";
+    version = "3.5.6";
+    sha256 = "sha256-Unzs9rX/0MlQprSvScdBCCFMeLCaGzWsMbcFqSKY2XY=";
+  };
+
+  patches = [ ./remove-chmod.patch ];
+
+  postInstall = ''
+    ln -sf ${sumneko-lua-language-server}/bin/lua-language-server \
+      $out/$installPrefix/server/bin/lua-language-server
+  '';
+
+  meta = with lib; {
+    description = "The Lua language server provides various language features for Lua to make development easier and faster.";
+    homepage = "https://marketplace.visualstudio.com/items?itemName=sumneko.lua";
+    license = licenses.mit;
+    maintainers = with maintainers; [ lblasc ];
+  };
+}

pkgs/applications/editors/vscode/extensions/lua/remove-chmod.patch

···
+diff --git a/client/out/languageserver.js b/client/out/languageserver.js
+index 6c7429c..6f53aa4 100644
+--- a/client/out/languageserver.js
++++ b/client/out/languageserver.js
+@@ -79,11 +79,9 @@ class LuaClient {
+                     break;
+                 case "linux":
+                     command = this.context.asAbsolutePath(path.join('server', binDir ? binDir : 'bin-Linux', 'lua-language-server'));
+-                    yield fs.promises.chmod(command, '777');
+                     break;
+                 case "darwin":
+                     command = this.context.asAbsolutePath(path.join('server', binDir ? binDir : 'bin-macOS', 'lua-language-server'));
+-                    yield fs.promises.chmod(command, '777');
+                     break;
+             }
+             let serverOptions = {

pkgs/applications/editors/vscode/vscode.nix

···
   archive_fmt = if stdenv.isDarwin then "zip" else "tar.gz";
 
   sha256 = {
-    x86_64-linux = "0hj6rpg65ivnnvzfjm16vjpjzzqbabpw5ldrr78x7ddrr06h02z6";
-    x86_64-darwin = "01gskihfp5s0j4dw8nxmfsp0sav1zqlmylmvwhi1y2qqq4y9c3w9";
-    aarch64-linux = "07n1svlkd2ji4b6yvhci6qvx429xipp8y418cqq3173gw8v59lws";
-    aarch64-darwin = "0gr94l7lk54fhhhqbiv23hd7d25xilqlwla2dbs5c171nj9pz325";
-    armv7l-linux = "0nxnjrzwfvma9zl4x11r45qwqq8mk91cxg47mg33qgr22lvbgz63";
+    x86_64-linux = "0cf6zlwslii30877p5vb0varxs6ai5r1g9wxx1b45yrmp7rvda91";
+    x86_64-darwin = "0j9kb7j2rvrgc2dzxhi1nzs78lzhpkfk3gcqcq84hcsga0n59y03";
+    aarch64-linux = "1bf2kvnd2pz2sk26bq1wm868bvvmrg338ipysmryilhk0l490vcx";
+    aarch64-darwin = "1rwwrzabxgw2wryi6rp8sc1jqps54p7a3cjpn4q94kds8rk5j0qn";
+    armv7l-linux = "0p2kwfq74lz43vpfh90xfrqsz7nwgcjsvqwkifkchp1m3xnil742";
   }.${system} or throwSystem;
 in
   callPackage ./generic.nix rec {
     # Please backport all compatible updates to the stable release.
     # This is important for the extension ecosystem.
-    version = "1.72.1";
+    version = "1.72.2";
     pname = "vscode";
 
     executableName = "code" + lib.optionalString isInsiders "-insiders";

pkgs/applications/misc/archivy/default.nix

···
     click-plugins
     elasticsearch
     flask-compress
-    flask_login
+    flask-login
     flask-wtf
     html2text
     python-dotenv

pkgs/applications/misc/octoprint/default.nix

···
                 flask
                 flask-babel
                 flask_assets
-                flask_login
+                flask-login
                 flask-limiter
                 frozendict
                 future

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

···
   };
 
   kops_1_25 = mkKops rec {
-    version = "1.25.1";
-    sha256 = "sha256-wKmEdcORXBKQ1AjYr0tNimxs//tSNPO3VQpEPC2mieA=";
+    version = "1.25.2";
+    sha256 = "sha256-JJGb12uuOvZQ+bA82nrs9vKRT2hEvnPrOH8XNHfYVD8=";
     rev = "v${version}";
   };
 }

pkgs/applications/networking/flexget/default.nix

···
 
 python3Packages.buildPythonApplication rec {
   pname = "flexget";
-  version = "3.3.37";
+  version = "3.3.38";
 
   # Fetch from GitHub in order to use `requirements.in`
   src = fetchFromGitHub {
     owner = "flexget";
     repo = "flexget";
     rev = "refs/tags/v${version}";
-    hash = "sha256-9rNdl76taviGfy5va3VLmZpqH2nErAMhOg2gQQCfJyI=";
+    hash = "sha256-mOjI2pN/KEY//+i+2YmLjUqQwv223jYhu+KjPMRPAaw=";
   };
 
   postPatch = ''
···
     cherrypy
     flask-compress
     flask-cors
-    flask_login
+    flask-login
     flask-restful
     flask-restx
     flask

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

···
 
 stdenv.mkDerivation rec {
   pname = "signal-cli";
-  version = "0.11.3";
+  version = "0.11.4";
 
   # Building from source would be preferred, but is much more involved.
   src = fetchurl {
     url = "https://github.com/AsamK/signal-cli/releases/download/v${version}/signal-cli-${version}-Linux.tar.gz";
-    sha256 = "sha256-2Tn/04Bbj+mUsV0gftEUXQmFYWTQyVaPNHZQVk57Avo=";
+    sha256 = "sha256-1NwaR8EMH2EQKskkPSrfWbUu8Ib7DwI6UNL3nOtc/tM=";
   };
 
   buildInputs = lib.optionals stdenv.isLinux [ libmatthew_java dbus dbus_java ];

pkgs/applications/networking/powerdns-admin/default.nix

···
   };
 
   pythonDeps = with python.pkgs; [
-    flask flask_assets flask_login flask-sqlalchemy flask_migrate flask-seasurf flask_mail flask-session flask-sslify
+    flask flask_assets flask-login flask-sqlalchemy flask_migrate flask-seasurf flask_mail flask-session flask-sslify
     mysqlclient psycopg2 sqlalchemy
     cffi configobj cryptography bcrypt requests python-ldap pyotp qrcode dnspython
     gunicorn python3-saml pytz cssmin rjsmin authlib bravado-core

pkgs/applications/networking/shellhub-agent/default.nix

···
 
 buildGoModule rec {
   pname = "shellhub-agent";
-  version = "0.10.3";
+  version = "0.10.4";
 
   src = fetchFromGitHub {
     owner = "shellhub-io";
     repo = "shellhub";
     rev = "v${version}";
-    sha256 = "XYDS9g118jv7BoI0QSncZMPspSwcnAIFKdjUgttlTgU=";
+    sha256 = "ov1hA+3sKh9Ms5D3/+ubwcAp+skuIfB3pvsvNSUKiSE=";
   };
 
   modRoot = "./agent";

pkgs/applications/radio/multimon-ng/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "multimon-ng";
-  version = "1.1.9";
+  version = "1.2.0";
 
   src = fetchFromGitHub {
     owner = "EliasOenal";
     repo = "multimon-ng";
     rev = version;
-    sha256 = "01716cfhxfzsab9zjply9giaa4nn4b7rm3p3vizrwi7n253yiwm2";
+    sha256 = "sha256-Qk9zg3aSrEfC16wQqL/EMG6MPobX8dnJ1OLH8EMap0I=";
   };
 
   buildInputs = lib.optionals stdenv.isLinux [ libpulseaudio libX11 ];

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

···
 stdenvNoCC.mkDerivation
 rec {
   pname = "orchis-theme";
-  version = "2022-09-28";
+  version = "2022-10-19";
 
   src = fetchFromGitHub {
     repo = "Orchis-theme";
     owner = "vinceliuice";
     rev = version;
-    sha256 = "sha256-gabOn5ErJjDgqZCyIboMgFb1FqmDw8dljIskBENKTBg=";
+    sha256 = "sha256-1lJUrWkb8IoUyCMn8J4Lwvs/pWsibrY0pSXrepuQcug=";
   };
 
   nativeBuildInputs = [ gtk3 sassc ];

pkgs/development/compilers/cudatoolkit/redist/manifests/redistrib_11.8.0.json

···
+{
+    "release_date": "2022-10-03",
+    "cuda_cccl": {
+        "name": "CXX Core Compute Libraries",
+        "license": "CUDA Toolkit",
+        "version": "11.8.89",
+        "linux-x86_64": {
+            "relative_path": "cuda_cccl/linux-x86_64/cuda_cccl-linux-x86_64-11.8.89-archive.tar.xz",
+            "sha256": "99d77d9e4c75d5e4663e473577f1871e65bca4ea0b9023f544a3556f0c1776c7",
+            "md5": "01bef0511cad90660a0ff50bbb4615fe",
+            "size": "1006416"
+        },
+        "linux-ppc64le": {
+            "relative_path": "cuda_cccl/linux-ppc64le/cuda_cccl-linux-ppc64le-11.8.89-archive.tar.xz",
+            "sha256": "6d40a8f268ddf8befea453a827a140d6ecd1e02a437eb4ddf4fe1d7d35b66918",
+            "md5": "ea0ba182ff91a9b641b12ea627c593e0",
+            "size": "1006640"
+        },
+        "linux-sbsa": {
+            "relative_path": "cuda_cccl/linux-sbsa/cuda_cccl-linux-sbsa-11.8.89-archive.tar.xz",
+            "sha256": "b7cdd513d4ee079f3ebe78ae1e156b678fa4f7df096459ae5bea8dc63db8a4f4",
+            "md5": "708f4d01e5b5bbc2d0e8bcdea443424e",
+            "size": "1006188"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_cccl/windows-x86_64/cuda_cccl-windows-x86_64-11.8.89-archive.zip",
+            "sha256": "548fe5e0cf6a64568a61713cdb475306ce7445d98dfbbe7f910fd78a7f6b616c",
+            "md5": "b345dfa53a38008bf54ddc47af3594f7",
+            "size": "2570742"
+        },
+        "linux-aarch64": {
+            "relative_path": "cuda_cccl/linux-aarch64/cuda_cccl-linux-aarch64-11.8.89-archive.tar.xz",
+            "sha256": "454c6f6e30176e82590b130971b8d49931db4d16c8cd127eb7bc225e348114bd",
+            "md5": "c401a3d74db67fa342e017f041d73736",
+            "size": "1006656"
+        }
+    },
+    "cuda_compat": {
+        "name": "CUDA compat L4T",
+        "license": "CUDA Toolkit",
+        "version": "11.8.31339915",
+        "linux-aarch64": {
+            "relative_path": "cuda_compat/linux-aarch64/cuda_compat-linux-aarch64-11.8.31339915-archive.tar.xz",
+            "sha256": "7aa1b62da35b52eaa13e254d1072aff10c907416604e5e5cc1ddcebbfe341dc7",
+            "md5": "41cba7b241724ad04234dc3f20526525",
+            "size": "15780868"
+        }
+    },
+    "cuda_cudart": {
+        "name": "CUDA Runtime (cudart)",
+        "license": "CUDA Toolkit",
+        "version": "11.8.89",
+        "linux-x86_64": {
+            "relative_path": "cuda_cudart/linux-x86_64/cuda_cudart-linux-x86_64-11.8.89-archive.tar.xz",
+            "sha256": "56129e0c42df03ecb50a7bb23fc3285fa39af1a818f8826b183cf793529098bb",
+            "md5": "1087b1284b033511c34ac3f1d42e1ecd",
+            "size": "913876"
+        },
+        "linux-ppc64le": {
+            "relative_path": "cuda_cudart/linux-ppc64le/cuda_cudart-linux-ppc64le-11.8.89-archive.tar.xz",
+            "sha256": "8c0cc24e09e015079accc3c37c8fffd7bbeb04a688c9958a672785ffb785ffac",
+            "md5": "2ab98046768706eb1818c83a1dcc2bf6",
+            "size": "855176"
+        },
+        "linux-sbsa": {
+            "relative_path": "cuda_cudart/linux-sbsa/cuda_cudart-linux-sbsa-11.8.89-archive.tar.xz",
+            "sha256": "88f496a2f96f5bb2a9cb351e6704dfe6a45e713e571c958a3924b2a02e7adea0",
+            "md5": "ca730f28308a18a0311f0167338455b0",
+            "size": "855196"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_cudart/windows-x86_64/cuda_cudart-windows-x86_64-11.8.89-archive.zip",
+            "sha256": "988cc9e7d3785d4b1975521f312c57c6814cbf15e73a2b7941d961835f2a945e",
+            "md5": "5b6c4db1e2c621c0061994156d35b64a",
+            "size": "2987306"
+        },
+        "linux-aarch64": {
+            "relative_path": "cuda_cudart/linux-aarch64/cuda_cudart-linux-aarch64-11.8.89-archive.tar.xz",
+            "sha256": "e7622a46261df6424e8cd892e1631ef3bbfae90d0aace4a63fd35cdcffa9c788",
+            "md5": "aea3364b82bc403d589f1a62f461e8a8",
+            "size": "819640"
+        }
+    },
+    "cuda_cuobjdump": {
+        "name": "cuobjdump",
+        "license": "CUDA Toolkit",
+        "version": "11.8.86",
+        "linux-x86_64": {
+            "relative_path": "cuda_cuobjdump/linux-x86_64/cuda_cuobjdump-linux-x86_64-11.8.86-archive.tar.xz",
+            "sha256": "28218273db8ffeb3ae4b31bfb4e4d90f0ae3373454c7970703c063dfd0377ba7",
+            "md5": "60c880a2a3f13ce47b13d093b23bef55",
+            "size": "162092"
+        },
+        "linux-ppc64le": {
+            "relative_path": "cuda_cuobjdump/linux-ppc64le/cuda_cuobjdump-linux-ppc64le-11.8.86-archive.tar.xz",
+            "sha256": "c982c7dd7b6b8f9e8328ae0b67c9d7507ea58b64c893374766f77be3ce58ac6c",
+            "md5": "3a18aab2c893cc93c27a5b84766b6438",
+            "size": "205016"
+        },
+        "linux-sbsa": {
+            "relative_path": "cuda_cuobjdump/linux-sbsa/cuda_cuobjdump-linux-sbsa-11.8.86-archive.tar.xz",
+            "sha256": "a630e95396437d0a8643d0184e95ac10a7c85488eff23955c94d1270dd45af2e",
+            "md5": "09d2c9c7b11e8f492b8ca0faabd542b7",
+            "size": "171160"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_cuobjdump/windows-x86_64/cuda_cuobjdump-windows-x86_64-11.8.86-archive.zip",
+            "sha256": "9961e1770fdde91844938a7046d03d7dfa3c3ff7271f77e9e859ca84d631ebf4",
+            "md5": "83ad84a30f896afa36d7a385776b3b75",
+            "size": "3777109"
+        },
+        "linux-aarch64": {
+            "relative_path": "cuda_cuobjdump/linux-aarch64/cuda_cuobjdump-linux-aarch64-11.8.86-archive.tar.xz",
+            "sha256": "9ef1314c2e9b0149c3ffb07559cf1226bfd716515c92e6dbaf400863b3f4d44c",
+            "md5": "4e530c57a7f4dc4c38bb982790f7b76e",
+            "size": "170944"
+        }
+    },
+    "cuda_cupti": {
+        "name": "CUPTI",
+        "license": "CUDA Toolkit",
+        "version": "11.8.87",
+        "linux-x86_64": {
+            "relative_path": "cuda_cupti/linux-x86_64/cuda_cupti-linux-x86_64-11.8.87-archive.tar.xz",
+            "sha256": "b2ebc5672aa7b896b5986200d132933c37e72df6b0bf5ac25c9cb18c2c03057f",
+            "md5": "5fc2edc95353ab45f29a411823176ca9",
+            "size": "18049564"
+        },
+        "linux-ppc64le": {
+            "relative_path": "cuda_cupti/linux-ppc64le/cuda_cupti-linux-ppc64le-11.8.87-archive.tar.xz",
+            "sha256": "48e3bd8f14d5846e0fff88bcd712a6bf0fc9566095ff24462bccdf43506f5d6a",
+            "md5": "c2e083b0a944afabd0dc1432284b0cc6",
+            "size": "9535008"
+        },
+        "linux-sbsa": {
+            "relative_path": "cuda_cupti/linux-sbsa/cuda_cupti-linux-sbsa-11.8.87-archive.tar.xz",
+            "sha256": "d53c7e5da57d1e9df1f5bb3009e4964fbbcc8382906f64153ba4fab2ddeae607",
+            "md5": "6c9ba6e9045d95a667fe623f9a7f9347",
+            "size": "9307904"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_cupti/windows-x86_64/cuda_cupti-windows-x86_64-11.8.87-archive.zip",
+            "sha256": "a243ffc6b5cfd9ba469bc3dd02208186c4f1956e91d54e9bca295757edd9dafa",
+            "md5": "d4fdbcf3bb3e75c334f9a6b21d4cdf5f",
+            "size": "13045751"
+        },
+        "linux-aarch64": {
+            "relative_path": "cuda_cupti/linux-aarch64/cuda_cupti-linux-aarch64-11.8.87-archive.tar.xz",
+            "sha256": "a7d2b993dcfdec7bf24cd8e7cee292679bc351d95bc58e99e3394593f708fa80",
+            "md5": "a5041dd165f9ca49c16912a0bf586000",
+            "size": "6976012"
+        }
+    },
+    "cuda_cuxxfilt": {
+        "name": "CUDA cuxxfilt (demangler)",
+        "license": "CUDA Toolkit",
+        "version": "11.8.86",
+        "linux-x86_64": {
+            "relative_path": "cuda_cuxxfilt/linux-x86_64/cuda_cuxxfilt-linux-x86_64-11.8.86-archive.tar.xz",
+            "sha256": "42e41e765fa0577c32706c9fd50016230d06e54dacb760f41ded7093923927af",
+            "md5": "165cd45c312f49edf66d30004e242aa8",
+            "size": "185836"
+        },
+        "linux-ppc64le": {
+            "relative_path": "cuda_cuxxfilt/linux-ppc64le/cuda_cuxxfilt-linux-ppc64le-11.8.86-archive.tar.xz",
+            "sha256": "00699d77a701372fb06d5c0d1eb6c51858f2b1aa97ae103589f434aebaa4999f",
+            "md5": "3159fa2ede95d25c22a15819d3265896",
+            "size": "179528"
+        },
+        "linux-sbsa": {
+            "relative_path": "cuda_cuxxfilt/linux-sbsa/cuda_cuxxfilt-linux-sbsa-11.8.86-archive.tar.xz",
+            "sha256": "c3c5802ff0c9fe96db03b49be6da4298258459e067138b868378f067cf31ea65",
+            "md5": "f48b56257116197573daddb3b8c2f78e",
+            "size": "172016"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_cuxxfilt/windows-x86_64/cuda_cuxxfilt-windows-x86_64-11.8.86-archive.zip",
+            "sha256": "a852b129290c1f9084ca7b626d5972d32fe5ec190ad55878c1c0993566d369c1",
+            "md5": "818838b992877c87396c390369143506",
+            "size": "168499"
+        },
+        "linux-aarch64": {
+            "relative_path": "cuda_cuxxfilt/linux-aarch64/cuda_cuxxfilt-linux-aarch64-11.8.86-archive.tar.xz",
+            "sha256": "0f838658f46e86cddf37af16928a9f971335d03d79ddb53d71b3329e5c1834ce",
+            "md5": "86b33cc615f1af37a45a998224e4680a",
+            "size": "171664"
+        }
+    },
+    "cuda_demo_suite": {
+        "name": "CUDA Demo Suite",
+        "license": "CUDA Toolkit",
+        "version": "11.8.86",
+        "linux-x86_64": {
+            "relative_path": "cuda_demo_suite/linux-x86_64/cuda_demo_suite-linux-x86_64-11.8.86-archive.tar.xz",
+            "sha256": "18cd11f6b846a855f34b949aa87477f5978d1462bc4c354e6a39af929f505b72",
+            "md5": "791ea9fa085582efac7e68b795f33f0d",
+            "size": "3993532"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_demo_suite/windows-x86_64/cuda_demo_suite-windows-x86_64-11.8.86-archive.zip",
+            "sha256": "35ebaba27ba4c91962e069847ab8c355305b76139a342ac0945173658a4cbf40",
+            "md5": "f38e557fd705098963ddd65cf407c9d5",
+            "size": "5050011"
+        }
+    },
+    "cuda_documentation": {
+        "name": "CUDA Documentation",
+        "license": "CUDA Toolkit",
+        "version": "11.8.86",
+        "linux-x86_64": {
+            "relative_path": "cuda_documentation/linux-x86_64/cuda_documentation-linux-x86_64-11.8.86-archive.tar.xz",
+            "sha256": "45355431a1cc1edd78db903aba6e50f548cbf34dc1a77f9c56ac7c294ddd0799",
+            "md5": "dfc70528af84c65b7262f824ee8c1289",
+            "size": "67156"
+        },
+        "linux-ppc64le": {
+            "relative_path": "cuda_documentation/linux-ppc64le/cuda_documentation-linux-ppc64le-11.8.86-archive.tar.xz",
+            "sha256": "7594463c636373abd1f09581b5da6767eca7d7f5218f96c700b932d9fb3ba8d3",
+            "md5": "cee8eaafed9470a7b12da8515d77187b",
+            "size": "67052"
+        },
+        "linux-sbsa": {
+            "relative_path": "cuda_documentation/linux-sbsa/cuda_documentation-linux-sbsa-11.8.86-archive.tar.xz",
+            "sha256": "41958cbfc53e170ed60140d2501a6fa00a0c2c6aa5496594ee6ee76c93b2da75",
+            "md5": "7898fc3e98473293441ea75bf438214d",
+            "size": "67076"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_documentation/windows-x86_64/cuda_documentation-windows-x86_64-11.8.86-archive.zip",
+            "sha256": "1f7b0c60be931debf0bbf1ff6ddecd8c61ae19c27ed370fabda0cbcfa2075ba5",
+            "md5": "df6b8628ac018257fdd23c7fc8646f97",
+            "size": "105364"
+        },
+        "linux-aarch64": {
+            "relative_path": "cuda_documentation/linux-aarch64/cuda_documentation-linux-aarch64-11.8.86-archive.tar.xz",
+            "sha256": "9879ba1dc577e22670d4575de80a64dd86cd02a78644af84c8aaab5f31972df2",
+            "md5": "46f135b33cad414f6e74cfab19874a27",
+            "size": "67100"
+        }
+    },
+    "cuda_gdb": {
+        "name": "CUDA GDB",
+        "license": "CUDA Toolkit",
+        "version": "11.8.86",
+        "linux-x86_64": {
+            "relative_path": "cuda_gdb/linux-x86_64/cuda_gdb-linux-x86_64-11.8.86-archive.tar.xz",
+            "sha256": "15252a58df4c2b09dfd3c4bf91c3aebdb2bbb84a61573d92690076ee5066bdff",
+            "md5": "008e94bb7b3f4e0208ceea015a962262",
+            "size": "64334476"
+        },
+        "linux-ppc64le": {
+            "relative_path": "cuda_gdb/linux-ppc64le/cuda_gdb-linux-ppc64le-11.8.86-archive.tar.xz",
+            "sha256": "2f79d874373af9f7ff6898f28b5ef8269f2182e03ce12cd716c56dda0bad0cdd",
+            "md5": "a13c9ea95b13bf3b70ac1d79fab1750f",
+            "size": "64179404"
+        },
+        "linux-sbsa": {
+            "relative_path": "cuda_gdb/linux-sbsa/cuda_gdb-linux-sbsa-11.8.86-archive.tar.xz",
+            "sha256": "acca29e2e8d341d058bb4cad76ec8c565fe15f39205aba72f5e92d360e49a360",
+            "md5": "e86e497ef3e6fd6b5099ba11e71c5ae5",
+            "size": "64001800"
+        },
+        "linux-aarch64": {
+            "relative_path": "cuda_gdb/linux-aarch64/cuda_gdb-linux-aarch64-11.8.86-archive.tar.xz",
+            "sha256": "b4e7dde3b001019a1e4ac7646cbae48e66a9642376745335a8bc245ad91b3a2c",
+            "md5": "827911d9bb2f98068c55111e4a6564f0",
+            "size": "63936148"
+        }
+    },
+    "cuda_memcheck": {
+        "name": "CUDA Memcheck",
+        "license": "CUDA Toolkit",
+        "version": "11.8.86",
+        "linux-x86_64": {
+            "relative_path": "cuda_memcheck/linux-x86_64/cuda_memcheck-linux-x86_64-11.8.86-archive.tar.xz",
+            "sha256": "539ce6b3cf03593f72f7830217145c87f94246b1c8c056fde2da82234aba2a3e",
+            "md5": "b3c4d2321f005cd7f4a2be2f647ebf5b",
+            "size": "139812"
+        },
+        "linux-ppc64le": {
+            "relative_path": "cuda_memcheck/linux-ppc64le/cuda_memcheck-linux-ppc64le-11.8.86-archive.tar.xz",
+            "sha256": "9f5a8ce507b2fa401180d3ca2213765069f8c5ea387f4164ea29cc32b22c9497",
+            "md5": "19ff70b8373e4c6e545427f1733ca64f",
+            "size": "147964"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_memcheck/windows-x86_64/cuda_memcheck-windows-x86_64-11.8.86-archive.zip",
+            "sha256": "387339972a16daefb5aca029d9d8d9c5f2fc8d823ccd4f4b89d2a2767f19dc2d",
+            "md5": "d9deb261404f40461099d814c8699d2c",
+            "size": "172894"
+        }
+    },
+    "cuda_nsight": {
+        "name": "Nsight Eclipse Edition Plugin",
+        "license": "CUDA Toolkit",
+        "version": "11.8.86",
+        "linux-x86_64": {
+            "relative_path": "cuda_nsight/linux-x86_64/cuda_nsight-linux-x86_64-11.8.86-archive.tar.xz",
+            "sha256": "4568af4eb961fba800b629b9456e4bed82eebf6e4c0c152f83e415b23983699d",
+            "md5": "ea71a5e487e05343fda0f8317c681be3",
+            "size": "118607548"
+        },
+        "linux-ppc64le": {
+            "relative_path": "cuda_nsight/linux-ppc64le/cuda_nsight-linux-ppc64le-11.8.86-archive.tar.xz",
+            "sha256": "67d1a47e1b39c0969201a45bac527e597ec1fc0f268ab3a78ab0a94363be58f2",
+            "md5": "6bbdefd52ed09fce18d909fd6f18479e",
+            "size": "118607576"
+        }
+    },
+    "cuda_nvcc": {
+        "name": "CUDA NVCC",
+        "license": "CUDA Toolkit",
+        "version": "11.8.89",
+        "linux-x86_64": {
+            "relative_path": "cuda_nvcc/linux-x86_64/cuda_nvcc-linux-x86_64-11.8.89-archive.tar.xz",
+            "sha256": "7ee8450dbcc16e9fe5d2a7b567d6dec220c5894a94ac6640459e06231e3b39a5",
+            "md5": "ea3b1b2afc8cfa824328adbe998a4a76",
+            "size": "43230952"
+        },
+        "linux-ppc64le": {
+            "relative_path": "cuda_nvcc/linux-ppc64le/cuda_nvcc-linux-ppc64le-11.8.89-archive.tar.xz",
+            "sha256": "16fcfac1ef89584a36bf725b1706c51ecf9754acc712600f5f3e70f6ba119c8c",
+            "md5": "bee55785b363cbec80cafd90d750aae8",
+            "size": "40307408"
+        },
+        "linux-sbsa": {
+            "relative_path": "cuda_nvcc/linux-sbsa/cuda_nvcc-linux-sbsa-11.8.89-archive.tar.xz",
+            "sha256": "17d30d924a1d6ff5748a0b6a4e7c25fd39644250cef9184fba520362f70ff798",
+            "md5": "dbaf022f1014ce621935c8bbb96113f0",
+            "size": "39022020"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_nvcc/windows-x86_64/cuda_nvcc-windows-x86_64-11.8.89-archive.zip",
+            "sha256": "4cdd7555f31186e5af0b14ab761838bbc8b5e6441589f5bb326930c7a502dcd3",
+            "md5": "240a8b9fca8d478aed61d9863e2cf4d3",
+            "size": "57346486"
+        },
+        "linux-aarch64": {
+            "relative_path": "cuda_nvcc/linux-aarch64/cuda_nvcc-linux-aarch64-11.8.89-archive.tar.xz",
+            "sha256": "e6cd1a039b5318cabc848840f0e660c4e0971186ae84ff0b2a56246b898ace1e",
+            "md5": "e3974c22515f9f20c44d9225de994696",
+            "size": "39063696"
+        }
+    },
+    "cuda_nvdisasm": {
+        "name": "CUDA nvdisasm",
+        "license": "CUDA Toolkit",
+        "version": "11.8.86",
+        "linux-x86_64": {
+            "relative_path": "cuda_nvdisasm/linux-x86_64/cuda_nvdisasm-linux-x86_64-11.8.86-archive.tar.xz",
+            "sha256": "9c1a92d012ec7e63334863a70f8c48b25d3a7df13253813318454358eeaa4400",
+            "md5": "76f004fb938f650841744b54fba3e0a1",
+            "size": "50769012"
+        },
+        "linux-ppc64le": {
+            "relative_path": "cuda_nvdisasm/linux-ppc64le/cuda_nvdisasm-linux-ppc64le-11.8.86-archive.tar.xz",
+            "sha256": "af86ce4c1a69be36b3d3363cbf2c47d752e916bf2690b7d7a845d78da10a02c0",
+            "md5": "3892df811a27b3566f447617b333aba9",
+            "size": "50762364"
+        },
+        "linux-sbsa": {
+            "relative_path": "cuda_nvdisasm/linux-sbsa/cuda_nvdisasm-linux-sbsa-11.8.86-archive.tar.xz",
+            "sha256": "8e6f10a708937283919ebd57ba55a5a3575a751c92f63ac9a99f5bcfda8ac1dc",
+            "md5": "ab35abb462f5eed823244a54341f966f",
+            "size": "50707044"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_nvdisasm/windows-x86_64/cuda_nvdisasm-windows-x86_64-11.8.86-archive.zip",
+            "sha256": "56888ecebbac419f1d5e91bff33ea1268fda12a3ce8818b0c6f360521cf07152",
+            "md5": "f6fc3655bed1293c8ff9bc96f06ecab9",
+            "size": "51000989"
+        },
+        "linux-aarch64": {
+            "relative_path": "cuda_nvdisasm/linux-aarch64/cuda_nvdisasm-linux-aarch64-11.8.86-archive.tar.xz",
+            "sha256": "578604e16d2c687a41fe1beb9eff44a72ad7e0ae9acc147fe28c37e1d3962f8a",
+            "md5": "67ae5c58f02a38a90159563438f8bf4b",
+            "size": "50697028"
+        }
+    },
+    "cuda_nvml_dev": {
+        "name": "CUDA NVML Headers",
+        "license": "CUDA Toolkit",
+        "version": "11.8.86",
+        "linux-x86_64": {
+            "relative_path": "cuda_nvml_dev/linux-x86_64/cuda_nvml_dev-linux-x86_64-11.8.86-archive.tar.xz",
+            "sha256": "2a03b591f7e6714811f34f807a76be1dea7d68788c898ab4a21ec2ccecf2e368",
+            "md5": "03ab04f1f7ff9557e4eafa22d3600cee",
+            "size": "78320"
+        },
+        "linux-ppc64le": {
+            "relative_path": "cuda_nvml_dev/linux-ppc64le/cuda_nvml_dev-linux-ppc64le-11.8.86-archive.tar.xz",
+            "sha256": "b6b067595b9721409092b44d1fc0b5373a0368faed984150aa27545f96adc1dd",
+            "md5": "0f93570ff9c5ab184755dc4be71aa7e9",
+            "size": "78388"
+        },
+        "linux-sbsa": {
+            "relative_path": "cuda_nvml_dev/linux-sbsa/cuda_nvml_dev-linux-sbsa-11.8.86-archive.tar.xz",
+            "sha256": "4b759ba07830b6394cf6d28c0e0e1a3e8bf88adfd5df575812dc1e1f9308f6d5",
+            "md5": "930827da97dd8f43a17bdf395e8bfb7e",
+            "size": "78948"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_nvml_dev/windows-x86_64/cuda_nvml_dev-windows-x86_64-11.8.86-archive.zip",
+            "sha256": "8eb977d7ed61eaa70a32963f1c2bd63ef92710a5a6486800125dec4ed8ebd6fb",
+            "md5": "8b4e968ead1fd332feedacb692009c57",
+            "size": "110045"
+        },
+        "linux-aarch64": {
+            "relative_path": "cuda_nvml_dev/linux-aarch64/cuda_nvml_dev-linux-aarch64-11.8.86-archive.tar.xz",
+            "sha256": "233c4f3ed5429930284b32c2b755ca01c4f2899e1dbb9036c738af85c874d53b",
+            "md5": "eca97d5c09108fcccc8e5ce10e9dedee",
+            "size": "78916"
+        }
+    },
+    "cuda_nvprof": {
+        "name": "CUDA nvprof",
+        "license": "CUDA Toolkit",
+        "version": "11.8.87",
+        "linux-x86_64": {
+            "relative_path": "cuda_nvprof/linux-x86_64/cuda_nvprof-linux-x86_64-11.8.87-archive.tar.xz",
+            "sha256": "cc01bc16f11b3aca89539a750c458121a4390d7694842627ca0221cc0b537107",
+            "md5": "a55fb3f318f5ea9fbdbfeb775952554f",
+            "size": "1955928"
+        },
+        "linux-ppc64le": {
+            "relative_path": "cuda_nvprof/linux-ppc64le/cuda_nvprof-linux-ppc64le-11.8.87-archive.tar.xz",
+            "sha256": "8e3ec9c4da81e88033e1ce013a995ac51a7c5e158c7fbbae8383e706356c244a",
+            "md5": "adf1828636a2c57333434d62aa725767",
+            "size": "1608680"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_nvprof/windows-x86_64/cuda_nvprof-windows-x86_64-11.8.87-archive.zip",
+            "sha256": "24f0cdf3692241efb8948230ea82b57245ae9654fafdcbea31314b06a7527580",
+            "md5": "b1ffe59994228212c4d58189a9e9cd31",
+            "size": "1599731"
+        }
+    },
+    "cuda_nvprune": {
+        "name": "CUDA nvprune",
+        "license": "CUDA Toolkit",
+        "version": "11.8.86",
+        "linux-x86_64": {
+            "relative_path": "cuda_nvprune/linux-x86_64/cuda_nvprune-linux-x86_64-11.8.86-archive.tar.xz",
+            "sha256": "6165a58e3b17dba210eb7fa6bab0b7c82aa83d6584e21adc54e9ce820f4a02b2",
+            "md5": "f6bb6d9a16863a54c12c79796c711dee",
+            "size": "55788"
+        },
+        "linux-ppc64le": {
+            "relative_path": "cuda_nvprune/linux-ppc64le/cuda_nvprune-linux-ppc64le-11.8.86-archive.tar.xz",
+            "sha256": "ee82495f51873831b5448b6181c05d1d8ef3abb7aa5d9e93c7e4f47fd1e0ee49",
+            "md5": "850be2894997205633df0f20d651b488",
+            "size": "56360"
+        },
+        "linux-sbsa": {
+            "relative_path": "cuda_nvprune/linux-sbsa/cuda_nvprune-linux-sbsa-11.8.86-archive.tar.xz",
+            "sha256": "c113d2340e4c91f7ee32e123f6a7736a070b79521bf33787a066fbb626790954",
+            "md5": "56578ad334bc57ee224eba840f6e055f",
+            "size": "48008"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_nvprune/windows-x86_64/cuda_nvprune-windows-x86_64-11.8.86-archive.zip",
+            "sha256": "75f77f308dfd216925e3ec02b2a2a0631d3cc72e023ba52b29b902f508dc6bf0",
+            "md5": "12512ae51bfedba3cb6767eff3435d7a",
+            "size": "145633"
+        },
+        "linux-aarch64": {
+            "relative_path": "cuda_nvprune/linux-aarch64/cuda_nvprune-linux-aarch64-11.8.86-archive.tar.xz",
+            "sha256": "090030bc5e4b65cb2d64cdb10964ae555b1db2f3a1c9446db17bf901c303b3f1",
+            "md5": "8e6be3ba89e40ba208e4c6959ad11564",
+            "size": "47924"
+        }
+    },
+    "cuda_nvrtc": {
+        "name": "CUDA NVRTC",
+        "license": "CUDA Toolkit",
+        "version": "11.8.89",
+        "linux-x86_64": {
+            "relative_path": "cuda_nvrtc/linux-x86_64/cuda_nvrtc-linux-x86_64-11.8.89-archive.tar.xz",
+            "sha256": "4bde6bdd6550110b91a5b8e442579c26ddf3a4bc9d380bed03daee8bf70a5286",
+            "md5": "f09fddad27e3d6896f472fcd37df2e61",
+            "size": "29507552"
+        },
+        "linux-ppc64le": {
+            "relative_path": "cuda_nvrtc/linux-ppc64le/cuda_nvrtc-linux-ppc64le-11.8.89-archive.tar.xz",
+            "sha256": "c4c305c31b38afb66e69c522263e6c04e8a08425330eebf7323a9f9d489d5a58",
+            "md5": "86bcf8a01a3fb1e4d00f2ea706ef189f",
+            "size": "27515068"
+        },
+        "linux-sbsa": {
+            "relative_path": "cuda_nvrtc/linux-sbsa/cuda_nvrtc-linux-sbsa-11.8.89-archive.tar.xz",
+            "sha256": "d81246bc36adb4664a816ebebd2a572b92a74b3a36a830454fc91a13bdad7d18",
+            "md5": "700eff66b08ad3fcb727abd8ca9cf814",
+            "size": "27381644"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_nvrtc/windows-x86_64/cuda_nvrtc-windows-x86_64-11.8.89-archive.zip",
+            "sha256": "e5d571247e71e0b0922a929516175844efa9e7ac424ed3c1b764bffb4899d3c9",
+            "md5": "b10471319dd70571927accc50a739781",
+            "size": "95854990"
+        },
+        "linux-aarch64": {
+            "relative_path": "cuda_nvrtc/linux-aarch64/cuda_nvrtc-linux-aarch64-11.8.89-archive.tar.xz",
+            "sha256": "89f3f8067b1a5812b0c46a24b4a82864516bf7026c951f8ccfe91c2b7c430596",
+            "md5": "7dc9f9c8419d26b6c4c7d8a6322e9bc7",
+            "size": "27383920"
+        }
+    },
+    "cuda_nvtx": {
+        "name": "CUDA NVTX",
+        "license": "CUDA Toolkit",
+        "version": "11.8.86",
+        "linux-x86_64": {
+            "relative_path": "cuda_nvtx/linux-x86_64/cuda_nvtx-linux-x86_64-11.8.86-archive.tar.xz",
+            "sha256": "d08af53e4116d5535112680c6f8a6774744c625a260bc5a64399a3be35700201",
+            "md5": "34a29024041db12d6c39c4db19276674",
+            "size": "48184"
+        },
+        "linux-ppc64le": {
+            "relative_path": "cuda_nvtx/linux-ppc64le/cuda_nvtx-linux-ppc64le-11.8.86-archive.tar.xz",
+            "sha256": "e0162a4e404079650b2cdcfb21a77eca69a70a9670a68cb368bb7b567a6a78d5",
+            "md5": "a95cb8d1ff95be59223602c44fff060d",
+            "size": "48148"
+        },
+        "linux-sbsa": {
+            "relative_path": "cuda_nvtx/linux-sbsa/cuda_nvtx-linux-sbsa-11.8.86-archive.tar.xz",
+            "sha256": "b5f1835ef51e7584a0ec16ff2c573c59f91fac4defbfc78de31e93514d50e5ff",
+            "md5": "487458d132db455e585369653d712ff7",
+            "size": "48800"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_nvtx/windows-x86_64/cuda_nvtx-windows-x86_64-11.8.86-archive.zip",
+            "sha256": "133c8c61904c06f1273dac35c0d602765e6a9f14175c9572b8c76b8b3d052105",
+            "md5": "ee20c858be84a6eb61830693f0c9d5a2",
+            "size": "65690"
+        },
+        "linux-aarch64": {
+            "relative_path": "cuda_nvtx/linux-aarch64/cuda_nvtx-linux-aarch64-11.8.86-archive.tar.xz",
+            "sha256": "780c37fd80f25f15efb72827d7d439d70618b3ead5ea6ff99727b9656ef3d6ef",
+            "md5": "0df92af46da66b19e5e488bb5130f401",
+            "size": "48092"
+        }
+    },
+    "cuda_nvvp": {
+        "name": "CUDA NVVP",
+        "license": "CUDA Toolkit",
+        "version": "11.8.87",
+        "linux-x86_64": {
+            "relative_path": "cuda_nvvp/linux-x86_64/cuda_nvvp-linux-x86_64-11.8.87-archive.tar.xz",
+            "sha256": "68a1ff1118220c7e1d3852de52110b36251045635dd7c4a42eae9a6a3e31116c",
+            "md5": "0316f5eb34c2597a21b984b32a2130fc",
+            "size": "117590868"
+        },
+        "linux-ppc64le": {
+            "relative_path": "cuda_nvvp/linux-ppc64le/cuda_nvvp-linux-ppc64le-11.8.87-archive.tar.xz",
+            "sha256": "1188a21ebb4f4d8a2cddffea5d6317b1863fce8ef9c9cffba678b37552e4f511",
+            "md5": "c078f22f422a4da514a66528eea3cb42",
+            "size": "117029624"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_nvvp/windows-x86_64/cuda_nvvp-windows-x86_64-11.8.87-archive.zip",
+            "sha256": "8e0f1da8541612ad5f21936a4c237fdce97d1fb4e8bc234698c15f2052db170a",
+            "md5": "b30aaf5036a5069ffc6a796e2af0692f",
+            "size": "120361858"
+        }
+    },
+    "cuda_profiler_api": {
+        "name": "CUDA Profiler API",
+        "license": "CUDA Toolkit",
+        "version": "11.8.86",
+        "linux-x86_64": {
+            "relative_path": "cuda_profiler_api/linux-x86_64/cuda_profiler_api-linux-x86_64-11.8.86-archive.tar.xz",
+            "sha256": "0845942ac7f6fac6081780c32e0d95c883c786638b54d5a8eda05fde8089d532",
+            "md5": "b45edeb69dee2eea33e63517b52c1242",
+            "size": "16140"
+        },
+        "linux-ppc64le": {
+            "relative_path": "cuda_profiler_api/linux-ppc64le/cuda_profiler_api-linux-ppc64le-11.8.86-archive.tar.xz",
+            "sha256": "cd0d212a4a49ee1d709fcd1d46eed5b34087d91d2465e342622caf7b173b1e34",
+            "md5": "478ec6b63bbcd8298fe6d9e8e231a98d",
+            "size": "16144"
+        },
+        "linux-sbsa": {
+            "relative_path": "cuda_profiler_api/linux-sbsa/cuda_profiler_api-linux-sbsa-11.8.86-archive.tar.xz",
+            "sha256": "472bbce7395e259ac609b6591cf4f01f2c7aae0af2562f77bf1433a3f578c6ee",
+            "md5": "56075a87654f2d9742a4a2c14618ebc2",
+            "size": "16144"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_profiler_api/windows-x86_64/cuda_profiler_api-windows-x86_64-11.8.86-archive.zip",
+            "sha256": "64f9ff04d1660ca0d611c8ac60ace7124f3e647519d67f78f681277e1c9221cc",
+            "md5": "ebd55b552f4fa46887cc9184495c40e1",
+            "size": "20587"
+        },
+        "linux-aarch64": {
+            "relative_path": "cuda_profiler_api/linux-aarch64/cuda_profiler_api-linux-aarch64-11.8.86-archive.tar.xz",
+            "sha256": "567818017d8eed04c7ea5bd3d7aacadc3008e32d33773feef55260c6473f9920",
+            "md5": "a7958e6be9d55cedbab6b245f58c950d",
+            "size": "16144"
+        }
+    },
+    "cuda_sanitizer_api": {
+        "name": "CUDA Compute Sanitizer API",
+        "license": "CUDA Toolkit",
+        "version": "11.8.86",
+        "linux-x86_64": {
+            "relative_path": "cuda_sanitizer_api/linux-x86_64/cuda_sanitizer_api-linux-x86_64-11.8.86-archive.tar.xz",
+            "sha256": "d5536917cbb0e2a1a5287e57e7c47e8645117a5a514cdbfd0da686986db71e75",
+            "md5": "5ca11ca504fae4bb3578a7ac04a3dff6",
+            "size": "8274596"
+        },
+        "linux-ppc64le": {
+            "relative_path": "cuda_sanitizer_api/linux-ppc64le/cuda_sanitizer_api-linux-ppc64le-11.8.86-archive.tar.xz",
+            "sha256": "b76e464506821e4643d536f79c650e07a6c42de075d124fa885e449b138f21d4",
+            "md5": "bfbcbf2d8167824b82d74eaabe4260f6",
+            "size": "7715068"
+        },
+        "linux-sbsa": {
+            "relative_path": "cuda_sanitizer_api/linux-sbsa/cuda_sanitizer_api-linux-sbsa-11.8.86-archive.tar.xz",
+            "sha256": "00975421bfa738b026ee1d89d41b76456d221cfe5737399604aca473f89ff922",
+            "md5": "c4030e1425847287f84b58a444af19e8",
+            "size": "6459140"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_sanitizer_api/windows-x86_64/cuda_sanitizer_api-windows-x86_64-11.8.86-archive.zip",
+            "sha256": "24fdaaa3a80dc1faea90a49213bef2098f0abbad8bd5108fada5b77d7ad00dcc",
+            "md5": "14aab57c462477036ba60f88e59fc415",
+            "size": "13572050"
+        },
+        "linux-aarch64": {
+            "relative_path": "cuda_sanitizer_api/linux-aarch64/cuda_sanitizer_api-linux-aarch64-11.8.86-archive.tar.xz",
+            "sha256": "0b1ec1096f87a796a0352188b89ac85bce19e97af504b72a2684f254de667d1e",
+            "md5": "6dfc8e796940d22fabd195c74d4f2b78",
+            "size": "3320104"
+        }
+    },
+    "fabricmanager": {
+        "name": "NVIDIA Fabric Manager",
+        "license": "NVIDIA Driver",
+        "version": "520.61.05",
+        "linux-x86_64": {
+            "relative_path": "fabricmanager/linux-x86_64/fabricmanager-linux-x86_64-520.61.05-archive.tar.xz",
+            "sha256": "a3c29b9a483ba9ccca41c95a1af1325cdcc4396abd6694199fdb3279f7e71221",
+            "md5": "7f90460c03ed9cbe4a50bdfb0bc8adf3",
+            "size": "1612804"
+        },
+        "linux-sbsa": {
+            "relative_path": "fabricmanager/linux-sbsa/fabricmanager-linux-sbsa-520.61.05-archive.tar.xz",
+            "sha256": "9333e7c4584b6edd73c497f1666afd4d1c8c4a36e2de8c9ef36aeebf22cd2b07",
+            "md5": "54fa3cce18980ef9b3f764a9ba0b51cf",
+            "size": "1494656"
+        }
+    },
+    "libcublas": {
+        "name": "CUDA cuBLAS",
+        "license": "CUDA Toolkit",
+        "version": "11.11.3.6",
+        "linux-x86_64": {
+            "relative_path": "libcublas/linux-x86_64/libcublas-linux-x86_64-11.11.3.6-archive.tar.xz",
+            "sha256": "045e6455c9f8789b1c7ced19957c7904d23c221f4d1d75bb574a2c856aebae98",
+            "md5": "86f56e585870e5a95d173ab30d866d9c",
+            "size": "500681532"
+        },
+        "linux-ppc64le": {
+            "relative_path": "libcublas/linux-ppc64le/libcublas-linux-ppc64le-11.11.3.6-archive.tar.xz",
+            "sha256": "27b07d1fa375404ed0f7ce37573de1c8a5ff8c313b9f388ee7b4ff41d4a8409f",
+            "md5": "c6b15c77cbd467d4fa3dc4c97dbf2aaa",
+            "size": "377908948"
+        },
+        "linux-sbsa": {
+            "relative_path": "libcublas/linux-sbsa/libcublas-linux-sbsa-11.11.3.6-archive.tar.xz",
+            "sha256": "38fe90cbbc7da3dbdcd8c29e0fcd60f69baf580d9b3f71a4ee102e3c7fc30b3d",
+            "md5": "87306fc3764e990423d21bfe4153bcc8",
+            "size": "377934916"
+        },
+        "windows-x86_64": {
+            "relative_path": "libcublas/windows-x86_64/libcublas-windows-x86_64-11.11.3.6-archive.zip",
+            "sha256": "67b0934a6359e4ee26fff823c356021589d392c4fd49ca12624f570edc08e2b9",
+            "md5": "1915e7979597f6b877f24f03364eb0ca",
+            "size": "420850025"
+        },
+        "linux-aarch64": {
+            "relative_path": "libcublas/linux-aarch64/libcublas-linux-aarch64-11.11.3.6-archive.tar.xz",
+            "sha256": "05252a76ee24a73b4def52a52c3a4d08e790f3956b020dfaba56af0cc169b08a",
+            "md5": "e87d3390d507b22b8bafe94fb79fa110",
+            "size": "288337012"
+        }
+    },
+    "libcudla": {
+        "name": "cuDLA",
+        "license": "CUDA Toolkit",
+        "version": "11.8.86",
+        "linux-aarch64": {
+            "relative_path": "libcudla/linux-aarch64/libcudla-linux-aarch64-11.8.86-archive.tar.xz",
+            "sha256": "2fedefe9ebd567767e0079e168155f643100b7bf4ff6331c14f791290c932614",
+            "md5": "14b0a2506fa1377d54b5fefe3acf5420",
+            "size": "65508"
+        }
+    },
+    "libcufft": {
+        "name": "CUDA cuFFT",
+        "license": "CUDA Toolkit",
+        "version": "10.9.0.58",
+        "linux-x86_64": {
+            "relative_path": "libcufft/linux-x86_64/libcufft-linux-x86_64-10.9.0.58-archive.tar.xz",
+            "sha256": "eadca0b30a4a2c1f741fde88d6dd611604e488fdb51c676861eabc08d2c4612f",
+            "md5": "3bca3ded75663fa9c1924ba09c3cdc14",
+            "size": "274730492"
+        },
+        "linux-ppc64le": {
+            "relative_path": "libcufft/linux-ppc64le/libcufft-linux-ppc64le-10.9.0.58-archive.tar.xz",
+            "sha256": "c2203e0e48733acf40b76a7a3ff15d105d8c2f02dc8bb2865eb814e091ba0c5a",
+            "md5": "1f488aeeef7a93c08ac547b101c042e1",
+            "size": "274679080"
+        },
+        "linux-sbsa": {
+            "relative_path": "libcufft/linux-sbsa/libcufft-linux-sbsa-10.9.0.58-archive.tar.xz",
+            "sha256": "e2bec93081e31ee2f0234d2fa93c2b501de29d2143fae287fe729c3318811e56",
+            "md5": "23319a56cc345c5ebe2bf5c4d7cbe46e",
+            "size": "212419228"
+        },
+        "windows-x86_64": {
+            "relative_path": "libcufft/windows-x86_64/libcufft-windows-x86_64-10.9.0.58-archive.zip",
+            "sha256": "a4071a85e3983bf42ea7a2e9bebe3b0b3c9ac258668580adc32ee1c385f7556f",
+            "md5": "8d2069024c2bc29a2a0f84645a76f76a",
+            "size": "168982770"
+        },
+        "linux-aarch64": {
+            "relative_path": "libcufft/linux-aarch64/libcufft-linux-aarch64-10.9.0.58-archive.tar.xz",
+            "sha256": "7337babe858b3b9d267603207da5e450d24d7fdd8173c4c5d303f6586e83611c",
+            "md5": "ff1d058b48df190318f44004ae1d5013",
+            "size": "264578816"
+        }
+    },
+    "libcufile": {
+        "name": "CUDA cuFile",
+        "license": "CUDA Toolkit",
+        "version": "1.4.0.31",
+        "linux-x86_64": {
+            "relative_path": "libcufile/linux-x86_64/libcufile-linux-x86_64-1.4.0.31-archive.tar.xz",
+            "sha256": "c926846769a63f6626c3f0006cc4d82306850ec8aa3be3216458116a551fe76a",
+            "md5": "8bf5d11a64b95bbf53ccee02830358c3",
+            "size": "39957500"
+        },
+        "linux-aarch64": {
+            "relative_path": "libcufile/linux-aarch64/libcufile-linux-aarch64-1.4.0.31-archive.tar.xz",
+            "sha256": "bf434cf2ac47911daf10ee837ee7f9cc91cb2bbc83ad4ec004765b9c264d39ae",
+            "md5": "8af06935ae790bff51775615e546a398",
+            "size": "40473296"
+        }
+    },
+    "libcurand": {
+        "name": "CUDA cuRAND",
+        "license": "CUDA Toolkit",
+        "version": "10.3.0.86",
+        "linux-x86_64": {
+            "relative_path": "libcurand/linux-x86_64/libcurand-linux-x86_64-10.3.0.86-archive.tar.xz",
+            "sha256": "9d30be251c1a0463b52203f6514dac5062844c606d13e234d1386e80c83db279",
+            "md5": "60021684fd162fbf75db4b687de5debc",
+            "size": "83523868"
+        },
+        "linux-ppc64le": {
+            "relative_path": "libcurand/linux-ppc64le/libcurand-linux-ppc64le-10.3.0.86-archive.tar.xz",
+            "sha256": "7349ddfc41ceb2f80cd13bc0e26447f05eaf540ae55110cf8b8774ed2860228b",
+            "md5": "cc395eea8203f26e186eadff339d0be7",
+            "size": "83574916"
+        },
+        "linux-sbsa": {
+            "relative_path": "libcurand/linux-sbsa/libcurand-linux-sbsa-10.3.0.86-archive.tar.xz",
+            "sha256": "3df3571103b056ab354e616f1c0737b1b2a25a7875b98b1b9bf32dee94449699",
+            "md5": "402182e6ca2bbbdebc618c8a38141873",
+            "size": "83497320"
+        },
+        "windows-x86_64": {
+            "relative_path": "libcurand/windows-x86_64/libcurand-windows-x86_64-10.3.0.86-archive.zip",
+            "sha256": "aaccf56d68a63378edc05109c233ed47e185237c8d334f9df136923440a9a6b7",
+            "md5": "f693dc58062505b2f40e9255ff920b4d",
+            "size": "56863367"
+        },
+        "linux-aarch64": {
+            "relative_path": "libcurand/linux-aarch64/libcurand-linux-aarch64-10.3.0.86-archive.tar.xz",
+            "sha256": "56411f5ce1f7c8a0a6a9db0b50f3454321226ad82abf6a189b176efd86587b77",
+            "md5": "01ef8ebea1eb265284382245ebdb72f1",
+            "size": "82232816"
+        }
+    },
+    "libcusolver": {
+        "name": "CUDA cuSOLVER",
+        "license": "CUDA Toolkit",
+        "version": "11.4.1.48",
+        "linux-x86_64": {
+            "relative_path": "libcusolver/linux-x86_64/libcusolver-linux-x86_64-11.4.1.48-archive.tar.xz",
+            "sha256": "ed136d960d28001fef1fe896aab56ea3e6a886970ab732274c9306e1bec88c96",
+            "md5": "ce3c0bb9a696bbec942b0f3ba542fe08",
+            "size": "85082320"
+        },
+        "linux-ppc64le": {
+            "relative_path": "libcusolver/linux-ppc64le/libcusolver-linux-ppc64le-11.4.1.48-archive.tar.xz",
+            "sha256": "fa3bcc0a9b1fb8c9c4d9c866284c561be765f101175a37aaaf6b6c25e584dfa1",
+            "md5": "b4dc0b612c07f60fa06f411ac4522c67",
+            "size": "85064564"
+        },
+        "linux-sbsa": {
+            "relative_path": "libcusolver/linux-sbsa/libcusolver-linux-sbsa-11.4.1.48-archive.tar.xz",
+            "sha256": "554a404bc39eb8369b5ad90cc7bb45fdb33dae509bd9a34cb0cbeff831d8569a",
+            "md5": "bbb50591bf44a4de96932ddf97072ebb",
+            "size": "84284636"
+        },
+        "windows-x86_64": {
+            "relative_path": "libcusolver/windows-x86_64/libcusolver-windows-x86_64-11.4.1.48-archive.zip",
+            "sha256": "965298e47640b643827cd6fe4ca5cab3c5a97b4bedc5357e9b6551298d1f9c2c",
+            "md5": "23ba061f4482a84e72abcf7df8b544ec",
+            "size": "120198030"
+        },
+        "linux-aarch64": {
+            "relative_path": "libcusolver/linux-aarch64/libcusolver-linux-aarch64-11.4.1.48-archive.tar.xz",
+            "sha256": "25010c938487032feb4ff8efbe9e60d9cc2fe68e865ce263be0a2542929d16be",
+            "md5": "a440363c729a49b30551888d3c816ed5",
+            "size": "70468000"
+        }
+    },
+    "libcusparse": {
+        "name": "CUDA cuSPARSE",
+        "license": "CUDA Toolkit",
+        "version": "11.7.5.86",
+        "linux-x86_64": {
+            "relative_path": "libcusparse/linux-x86_64/libcusparse-linux-x86_64-11.7.5.86-archive.tar.xz",
+            "sha256": "9250fe539d4bd6a378581dc0b528e8cfc418b57f28545bf39d70cae762075df7",
+            "md5": "93b1c707413b5de5257190faf793047e",
+            "size": "227085840"
+        },
+        "linux-ppc64le": {
+            "relative_path": "libcusparse/linux-ppc64le/libcusparse-linux-ppc64le-11.7.5.86-archive.tar.xz",
+            "sha256": "1072e26dc118cbf9d6f061eddbff45f2da2eef6c87c2b8a64fd1586af91a2735",
+            "md5": "1bfca7f1de356eea5da55adc425bf3f5",
+            "size": "227171492"
+        },
+        "linux-sbsa": {
+            "relative_path": "libcusparse/linux-sbsa/libcusparse-linux-sbsa-11.7.5.86-archive.tar.xz",
+            "sha256": "191ae1f26b15955b743f6c4978c8562b973b16671a9f684368d501919f906ce5",
+            "md5": "1804e51f97d6d5cd8e9b8692202efa15",
+            "size": "226831828"
+        },
+        "windows-x86_64": {
+            "relative_path": "libcusparse/windows-x86_64/libcusparse-windows-x86_64-11.7.5.86-archive.zip",
+            "sha256": "b51a46f4f6bb9476ffe433a1dedad2c94a546c8a92e70dfed63207b64ff57e50",
+            "md5": "e8914191f10a4df1e9c869431c9aed0c",
+            "size": "201218990"
+        },
+        "linux-aarch64": {
+            "relative_path": "libcusparse/linux-aarch64/libcusparse-linux-aarch64-11.7.5.86-archive.tar.xz",
+            "sha256": "a7795a1f97ea1b7c1e5753294e7ddaecc3e99e18da29e1e9adcbd73e61946365",
+            "md5": "de93b81f33cd3887fe79970c1ab28e7c",
+            "size": "192532892"
+        }
+    },
+    "libnpp": {
+        "name": "CUDA NPP",
+        "license": "CUDA Toolkit",
+        "version": "11.8.0.86",
+        "linux-x86_64": {
+            "relative_path": "libnpp/linux-x86_64/libnpp-linux-x86_64-11.8.0.86-archive.tar.xz",
+            "sha256": "1aaacf07e4df2dda5f6246763fc89c1bb9af9d4723596f4530826bcae148f9b4",
+            "md5": "d30d8c48b7d0a836fc2386ebc9d0b471",
+            "size": "200538792"
+        },
+        "linux-ppc64le": {
+            "relative_path": "libnpp/linux-ppc64le/libnpp-linux-ppc64le-11.8.0.86-archive.tar.xz",
+            "sha256": "cc559ab9c4972e331b1b90b7ee6ab909c80f818a6f522885109f800ed6d9db1e",
+            "md5": "af75693a60e88ae68fee15e622bfb32a",
+            "size": "200739960"
+        },
+        "linux-sbsa": {
+            "relative_path": "libnpp/linux-sbsa/libnpp-linux-sbsa-11.8.0.86-archive.tar.xz",
+            "sha256": "cb5608a2a52fbe316bf89373e47c5b801ee4cbdbe8eaea777f8c4dcf4225c65e",
+            "md5": "6d4cb57caf765c53beba968626c56a10",
+            "size": "199830000"
+        },
+        "windows-x86_64": {
+            "relative_path": "libnpp/windows-x86_64/libnpp-windows-x86_64-11.8.0.86-archive.zip",
+            "sha256": "5cd2ba50234b0743242bab212bf742c114e274fd639ec9d79fd62e1295756d32",
+            "md5": "e931a386b39e10e7ab335841823f3e6e",
+            "size": "160781198"
+        },
+        "linux-aarch64": {
+            "relative_path": "libnpp/linux-aarch64/libnpp-linux-aarch64-11.8.0.86-archive.tar.xz",
+            "sha256": "1ef920c64610e03933ed94fc1dd34377c298c35bca83b9e864114dd7ad512c58",
+            "md5": "f58c5fd842623e8babc6b46a5dd83a1e",
+            "size": "174774196"
+        }
+    },
+    "libnvidia_nscq": {
+        "name": "NVIDIA NSCQ API",
+        "license": "NVIDIA Driver",
+        "version": "520.61.05",
+        "linux-x86_64": {
+            "relative_path": "libnvidia_nscq/linux-x86_64/libnvidia_nscq-linux-x86_64-520.61.05-archive.tar.xz",
+            "sha256": "3041cc4b7486e320467bab16350cf51acb84055b36df518b835dd801e18a1ec6",
+            "md5": "dfc5430590addc9cc5727d57739d78be",
+            "size": "339124"
+        },
+        "linux-sbsa": {
+            "relative_path": "libnvidia_nscq/linux-sbsa/libnvidia_nscq-linux-sbsa-520.61.05-archive.tar.xz",
+            "sha256": "c28cc5574846305479a3a2438278cf9ef67c640105a24f25c2cb2b92eebc16f0",
+            "md5": "4fd3355154c6bc70769189f9218ded28",
+            "size": "307812"
+        }
+    },
+    "libnvjpeg": {
+        "name": "CUDA nvJPEG",
+        "license": "CUDA Toolkit",
+        "version": "11.9.0.86",
+        "linux-x86_64": {
+            "relative_path": "libnvjpeg/linux-x86_64/libnvjpeg-linux-x86_64-11.9.0.86-archive.tar.xz",
+            "sha256": "2dd496ef4f974cf73ef293fd3de3b5b5abcaaf36150304c4f7bd0228e3e34e9d",
+            "md5": "0efa17e6a939eaf65268580725fff407",
+            "size": "2084164"
+        },
+        "linux-ppc64le": {
+            "relative_path": "libnvjpeg/linux-ppc64le/libnvjpeg-linux-ppc64le-11.9.0.86-archive.tar.xz",
+            "sha256": "2f3b7468c0b20a8de9fe6c93456cf5405f1eab70482964e35bf732aaa09ccaf0",
+            "md5": "8aa8bb109c68e9e9b9db4393cceb6f0c",
+            "size": "2098644"
+        },
+        "linux-sbsa": {
+            "relative_path": "libnvjpeg/linux-sbsa/libnvjpeg-linux-sbsa-11.9.0.86-archive.tar.xz",
+            "sha256": "bab943ceddc0d7103b0777953dca8cfb66db35b54fcee75187397345ada6e112",
+            "md5": "853fde580b85d0e5d095a9dc76d72f25",
+            "size": "1929336"
+        },
+        "windows-x86_64": {
+            "relative_path": "libnvjpeg/windows-x86_64/libnvjpeg-windows-x86_64-11.9.0.86-archive.zip",
+            "sha256": "caddf3d887a5bfb7db32757016fce18922838c889c80e910d91edd0644039116",
+            "md5": "876752c9a9da6109f5419ff4d1b1324d",
+            "size": "2054090"
+        }
+    },
+    "nsight_compute": {
+        "name": "Nsight Compute",
+        "license": "NVIDIA SLA",
+        "version": "2022.3.0.22",
+        "linux-x86_64": {
+            "relative_path": "nsight_compute/linux-x86_64/nsight_compute-linux-x86_64-2022.3.0.22-archive.tar.xz",
+            "sha256": "1ce06d1f7fb5b9124570db1e12a7caf0caa61d60f757c8d0bcb233f818cd3e0c",
+            "md5": "16f6fd94b2c477c6b4c4038bd79ddc3f",
+            "size": "578530596"
+        },
+        "linux-ppc64le": {
+            "relative_path": "nsight_compute/linux-ppc64le/nsight_compute-linux-ppc64le-2022.3.0.22-archive.tar.xz",
+            "sha256": "e7eb2794136cec15cbfcb2d69e230e1b28164091eee886cb17182000e4ffff8b",
+            "md5": "b0a5ae542e09a0c8f6b954804562f4ef",
+            "size": "179631780"
+        },
+        "linux-sbsa": {
+            "relative_path": "nsight_compute/linux-sbsa/nsight_compute-linux-sbsa-2022.3.0.22-archive.tar.xz",
+            "sha256": "95f817d0526e60a16dc918e9240bc2b4155216833b7beecde5308687d8aaaead",
+            "md5": "e19f502868ba6a20fb6de760313f7177",
+            "size": "336218564"
+        },
+        "windows-x86_64": {
+            "relative_path": "nsight_compute/windows-x86_64/nsight_compute-windows-x86_64-2022.3.0.22-archive.zip",
+            "sha256": "e72b239b8be0801f6377204949fb4696bf3cc8b86327f428f4bb8cbd55f7f110",
+            "md5": "564365913c7c6e107f7d970e573e5378",
+            "size": "477847800"
+        },
+        "linux-aarch64": {
+            "relative_path": "nsight_compute/linux-aarch64/nsight_compute-linux-aarch64-2022.3.0.22-archive.tar.xz",
+            "sha256": "bd1b3770c183bab6ef27e018d26db480a7d52495df1bb517b785b1732b083782",
+            "md5": "7795118b5706d4597bfd7ee65e2abd17",
+            "size": "697905636"
+        }
+    },
+    "nsight_nvtx": {
+        "name": "Nsight NVTX",
+        "license": "CUDA Toolkit",
+        "version": "1.21018621",
+        "windows-x86_64": {
+            "relative_path": "nsight_nvtx/windows-x86_64/nsight_nvtx-windows-x86_64-1.21018621-archive.zip",
+            "sha256": "d99b015bfb1308206f9d7c16ea401bf426fed3a5a99953b855fe4e68be5ed2d1",
+            "md5": "34ee04d45cfca1c4e3cbfba0ec8f6f80",
+            "size": "315692"
+        }
+    },
+    "nsight_systems": {
+        "name": "Nsight Systems",
+        "license": "NVIDIA SLA",
+        "version": "2022.4.2.1",
+        "linux-x86_64": {
+            "relative_path": "nsight_systems/linux-x86_64/nsight_systems-linux-x86_64-2022.4.2.1-archive.tar.xz",
+            "sha256": "372808c5d4e2c4b99ffe324f8947ae4f2b31ab406fd835409b3032f23198ed26",
+            "md5": "793910c8b14cd7471a1dc7d5a5a0b3f0",
+            "size": "196239560"
+        },
+        "linux-ppc64le": {
+            "relative_path": "nsight_systems/linux-ppc64le/nsight_systems-linux-ppc64le-2022.4.2.1-archive.tar.xz",
+            "sha256": "ab34e5818b6bbcdd1726509738e727b9500144868c8a8f48f348824bdf3c3ce2",
+            "md5": "dbd5ac2f2e5a72a033575e0de505de9b",
+            "size": "52933936"
+        },
+        "linux-sbsa": {
+            "relative_path": "nsight_systems/linux-sbsa/nsight_systems-linux-sbsa-2022.4.2.1-archive.tar.xz",
+            "sha256": "f7b1a917f279bf47caf87af1db1cf1681734fdfd00fe8fccd5bd7a2cfe6ade91",
+            "md5": "1621ec2e6dc63821288b1196d202450e",
+            "size": "185788748"
+        },
+        "windows-x86_64": {
+            "relative_path": "nsight_systems/windows-x86_64/nsight_systems-windows-x86_64-2022.4.2.1-archive.zip",
+            "sha256": "0a0df11d7cb449c82d7bcf96960740df482da78e698903941e0a9643af3c7b22",
+            "md5": "a5aa599af3a04405575f363139b52c43",
+            "size": "384428030"
+        }
+    },
+    "nsight_vse": {
+        "name": "Nsight Visual Studio Edition (VSE)",
+        "license": "NVIDIA SLA",
+        "version": "2022.3.0.22245",
+        "windows-x86_64": {
+            "relative_path": "nsight_vse/windows-x86_64/nsight_vse-windows-x86_64-2022.3.0.22245-archive.zip",
+            "sha256": "0de65ab3e57a42d63422fcb52d8cc813aed70cfa6603847508475775442e778c",
+            "md5": "385a2882cb154f2bd5e03ddd61ef1faf",
+            "size": "535810712"
+        }
+    },
+    "nvidia_driver": {
+        "name": "NVIDIA Linux Driver",
+        "license": "NVIDIA Driver",
+        "version": "520.61.05",
+        "linux-x86_64": {
+            "relative_path": "nvidia_driver/linux-x86_64/nvidia_driver-linux-x86_64-520.61.05-archive.tar.xz",
+            "sha256": "c28127087bfd4a865f3c7fcf16c6e5b0c21318d19268b5289c5d825e615888b7",
+            "md5": "3ecd427f21946334d48cca97f6c7587d",
+            "size": "409484656"
+        },
+        "linux-ppc64le": {
+            "relative_path": "nvidia_driver/linux-ppc64le/nvidia_driver-linux-ppc64le-520.61.05-archive.tar.xz",
+            "sha256": "0485cef7466d694900c9a6b990380c5be4504e3470dc89c6e667b7b0a6837c3c",
+            "md5": "282e06b3fa823b133f5174dc784067bf",
+            "size": "97602224"
+        },
+        "linux-sbsa": {
+            "relative_path": "nvidia_driver/linux-sbsa/nvidia_driver-linux-sbsa-520.61.05-archive.tar.xz",
+            "sha256": "e8de6ffdac2be419d7b940a00a0482de63a147db0acbc5265f27027c1b8f603a",
+            "md5": "b161fc8992e3b94a330bfc40b67a53a5",
+            "size": "260589160"
+        }
+    },
+    "nvidia_fs": {
+        "name": "NVIDIA filesystem",
+        "license": "CUDA Toolkit",
+        "version": "2.13.5",
+        "linux-x86_64": {
+            "relative_path": "nvidia_fs/linux-x86_64/nvidia_fs-linux-x86_64-2.13.5-archive.tar.xz",
+            "sha256": "f3962442f26be807b358c307cba5ffc45a7d8219a532d6152e66db238d778dbf",
+            "md5": "46ae5fef3efcb780a910f27877578117",
+            "size": "67792"
+        },
+        "linux-aarch64": {
+            "relative_path": "nvidia_fs/linux-aarch64/nvidia_fs-linux-aarch64-2.13.5-archive.tar.xz",
+            "sha256": "7970d053e76366e2e68aec2e61cd4eb39a749664345721742244b77f8ccbb151",
+            "md5": "6c15f64e3c1881f344e9d6aaa4a37a69",
+            "size": "67760"
+        }
+    },
+    "visual_studio_integration": {
+        "name": "CUDA Visual Studio Integration",
+        "license": "CUDA Toolkit",
+        "version": "11.8.86",
+        "windows-x86_64": {
+            "relative_path": "visual_studio_integration/windows-x86_64/visual_studio_integration-windows-x86_64-11.8.86-archive.zip",
+            "sha256": "67c847a57cc8664b2180ecbdd06b399b50cfcb871c9d04bad3ce1510485aee36",
+            "md5": "08c19db58ba62ebc15af19f52b63a71c",
+            "size": "517053"
+        }
+    }
+}

pkgs/development/compilers/cudatoolkit/versions.toml

···
 url = "https://developer.download.nvidia.com/compute/cuda/11.7.0/local_installers/cuda_11.7.0_515.43.04_linux.run"
 sha256 = "sha256-CH/fy7ofeVQ7H3jkOo39rF9tskLQQt3oIOFtwYWJLyY="
 gcc = "gcc11"
+
+["11.8"]
+version = "11.8.0"
+url = "https://developer.download.nvidia.com/compute/cuda/11.8.0/local_installers/cuda_11.8.0_520.61.05_linux.run"
+sha256 = "sha256-kiPErzrr5Ke77Zq9mxY7A6GzS4VfvCtKDRtwasCaWhY="
+gcc = "gcc11"

pkgs/development/interpreters/bats/default.nix

···
 
 resholve.mkDerivation rec {
   pname = "bats";
-  version = "1.8.0";
+  version = "1.8.2";
 
   src = fetchFromGitHub {
     owner = "bats-core";
     repo = "bats-core";
     rev = "v${version}";
-    sha256 = "sha256-dnNB82vEv49xzmH3r9dLL4aMIi61HQDr0gVin2H+jOw=";
+    sha256 = "sha256-Kitlx26cK2RiAC+PdRIdDLF5crorg6UB6uSzbKCrDHE=";
   };
 
   patchPhase = ''

pkgs/development/interpreters/luajit/2.0.nix

···
 callPackage ./default.nix {
   sourceVersion = { major = "2"; minor = "0"; patch = "5"; };
   inherit self passthruFun;
-  version = "2.0.5-2022-03-13";
-  rev = "93a65d3cc263aef2d2feb3d7ff2206aca3bee17e";
+  version = "2.0.5-2022-09-13";
+  rev = "46e62cd963a426e83a60f691dcbbeb742c7b3ba2";
   isStable = true;
-  hash = "sha256-Gp7OdfxBGkW59zxWUml2ugPABLUv2SezMiDblA/FZ7g=";
+  hash = "sha256-/XR9+6NjXs2TrUVKJNkH2h970BkDNFqMDJTWcy/bswU=";
   extraMeta = { # this isn't precise but it at least stops the useless Hydra build
     platforms = with lib; filter (p: !hasPrefix "aarch64-" p)
       (platforms.linux ++ platforms.darwin);

pkgs/development/interpreters/luajit/2.1.nix

···
 callPackage ./default.nix {
   sourceVersion = { major = "2"; minor = "1"; patch = "0"; };
   inherit self passthruFun;
-  version = "2.1.0-2022-04-05";
-  rev = "5e3c45c43bb0e0f1f2917d432e9d2dba12c42a6e";
+  version = "2.1.0-2022-10-04";
+  rev = "6c4826f12c4d33b8b978004bc681eb1eef2be977";
   isStable = false;
-  hash = "sha256-Q+34hJDgyCqmtThHbxR16Nn7zhq4Ql142No2rO57HL0=";
+  hash = "sha256-GMgoSVHrfIuLdk8mW9XgdemNFsAkkQR4wiGGjaAXAKg=";
 }

pkgs/development/libraries/science/math/cudnn/extension.nix

···
 
   inherit (final) callPackage;
   inherit (prev) cudatoolkit cudaVersion lib pkgs;
+  inherit (prev.lib.versions) major;
 
   ### CuDNN
 
···
     # Add all supported builds as attributes
     allBuilds = mapAttrs' (version: file: nameValuePair (computeName version) (buildCuDnnPackage (removeAttrs file ["fileVersion"]))) supportedVersions;
     # Set the default attributes, e.g. cudnn = cudnn_8_3_1;
-    defaultBuild = { "cudnn" = allBuilds.${computeName cuDnnDefaultVersion}; };
+    defaultBuild = { "cudnn" = if allBuilds ? ${computeName cuDnnDefaultVersion}
+      then allBuilds.${computeName cuDnnDefaultVersion}
+      else throw "cudnn-${cuDnnDefaultVersion} does not support your cuda version ${cudaVersion}"; };
   in allBuilds // defaultBuild;
 
   cuDnnVersions = let
···
         supportedCudaVersions = [ "11.0" "11.1" "11.2" "11.3" "11.4" "11.5" "11.6" "11.7" ];
       }
     ];
+    "8.5.0" = [
+      rec {
+        fileVersion = "10.2";
+        fullVersion = "8.5.0.96";
+        hash = "sha256-1mzhbbzR40WKkHnQLtJHhg0vYgf7G8a0OBcCwIOkJjM=";
+        url = "${urlPrefix}/v${majorMinorPatch fullVersion}/local_installers/${fileVersion}/cudnn-linux-x86_64-${fullVersion}_cuda${major fileVersion}-archive.tar.xz";
+        supportedCudaVersions = [ "10.2" ];
+      }
+      rec {
+        fileVersion = "11.7";
+        fullVersion = "8.5.0.96";
+        hash = "sha256-VFSm/ZTwCHKMqumtrZk8ToXvNjAuJrzkO+p9RYpee20=";
+        url = "${urlPrefix}/v${majorMinorPatch fullVersion}/local_installers/${fileVersion}/cudnn-linux-x86_64-${fullVersion}_cuda${major fileVersion}-archive.tar.xz";
+        supportedCudaVersions = [ "11.0" "11.1" "11.2" "11.3" "11.4" "11.5" "11.6" "11.7" ];
+      }
+    ];
+    "8.6.0" = [
+      rec {
+        fileVersion = "10.2";
+        fullVersion = "8.6.0.163";
+        hash = "sha256-t4sr/GrFqqdxu2VhaJQk5K1Xm/0lU4chXG8hVL09R9k=";
+        url = "${urlPrefix}/v${majorMinorPatch fullVersion}/local_installers/${fileVersion}/cudnn-linux-x86_64-${fullVersion}_cuda${major fileVersion}-archive.tar.xz";
+        supportedCudaVersions = [ "10.2" ];
+      }
+      rec {
+        fileVersion = "11.7";
+        fullVersion = "8.6.0.163";
+        hash = "sha256-u8OW30cpTGV+3AnGAGdNYIyxv8gLgtz0VHBgwhcRFZ4=";
+        url = "${urlPrefix}/v${majorMinorPatch fullVersion}/local_installers/${fileVersion}/cudnn-linux-x86_64-${fullVersion}_cuda${major fileVersion}-archive.tar.xz";
+        supportedCudaVersions = [ "11.0" "11.1" "11.2" "11.3" "11.4" "11.5" "11.6" "11.7" "11.8" ];
+      }
+    ];
   };
 
   # Default attributes
   cuDnnDefaultVersion = {
     "10.0" = "7.4.2";
     "10.1" = "7.6.5";
-    "10.2" = "8.3.2";
-    "11.0" = "8.3.2";
-    "11.1" = "8.3.2";
-    "11.2" = "8.3.2";
-    "11.3" = "8.3.2";
-    "11.4" = "8.3.2";
-    "11.5" = "8.3.2";
-    "11.6" = "8.3.2";
-    "11.7" = "8.4.0";
-  }.${cudaVersion} or "8.3.2";
+    "10.2" = "8.6.0";
+    "11.0" = "8.6.0";
+    "11.1" = "8.6.0";
+    "11.2" = "8.6.0";
+    "11.3" = "8.6.0";
+    "11.4" = "8.6.0";
+    "11.5" = "8.6.0";
+    "11.6" = "8.6.0";
+    "11.7" = "8.6.0";
+    "11.8" = "8.6.0";
+  }.${cudaVersion} or "8.6.0";
 
 in cuDnnPackages

pkgs/development/libraries/science/math/tensorrt/extension.nix

···
     # Add all supported builds as attributes
     allBuilds = mapAttrs' (version: file: nameValuePair (computeName version) (buildTensorRTPackage (removeAttrs file ["fileVersionCuda"]))) supportedVersions;
     # Set the default attributes, e.g. tensorrt = tensorrt_8_4;
-    defaultBuild = { "tensorrt" = allBuilds.${computeName tensorRTDefaultVersion}; };
+    defaultBuild = { "tensorrt" = if allBuilds ? ${computeName tensorRTDefaultVersion}
+      then allBuilds.${computeName tensorRTDefaultVersion}
+      else throw "tensorrt-${tensorRTDefaultVersion} does not support your cuda version ${cudaVersion}"; };
   in allBuilds // defaultBuild;
 
   tensorRTVersions = {

pkgs/development/python-modules/apache-airflow/default.nix

···
 , deprecated
 , dill
 , flask
-, flask_login
+, flask-login
 , flask-appbuilder
 , flask-caching
 , flask-session
···
     flask-caching
     flask-session
     flask-wtf
-    flask_login
+    flask-login
     GitPython
     graphviz
     gunicorn

pkgs/development/python-modules/flask-appbuilder/default.nix

···
 , email-validator
 , flask
 , flask-babel
-, flask_login
+, flask-login
 , flask-openid
 , flask-sqlalchemy
 , flask-wtf
···
     email-validator
     flask
     flask-babel
-    flask_login
+    flask-login
     flask-openid
     flask-sqlalchemy
     flask-wtf

pkgs/development/python-modules/flask-security-too/default.nix

···
 , blinker
 , email-validator
 , flask
-, flask_login
+, flask-login
 , flask_principal
 , flask-wtf
 , itsdangerous
···
     blinker
     email-validator
     flask
-    flask_login
+    flask-login
     flask_principal
     flask-wtf
     itsdangerous

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

···
+{ lib
+, buildPythonPackage
+, fetchFromGitHub
+, lxml
+, pytestCheckHook
+, requests
+}:
+
+buildPythonPackage rec {
+  pname = "inscriptis";
+  version = "2.3.1";
+  format = "setuptools";
+
+  src = fetchFromGitHub {
+    owner = "weblyzard";
+    repo = "inscriptis";
+    rev = version;
+    sha256 = "sha256-an/FTbujN2VnTYa0wngM8ugV1LNHJWM32RVqIbaW0KY=";
+  };
+
+  propagatedBuildInputs = [
+    lxml
+    requests
+  ];
+
+  checkInputs = [
+    pytestCheckHook
+  ];
+
+  pythonImportsCheck = [ "inscriptis" ];
+
+  meta = with lib; {
+    description = "inscriptis - HTML to text converter";
+    homepage = "https://github.com/weblyzard/inscriptis";
+    license = licenses.asl20;
+    maintainers = with maintainers; [ SuperSandro2000 ];
+  };
+}

pkgs/development/python-modules/jsonpath-ng/default.nix

···
 
 buildPythonPackage rec {
   pname = "jsonpath-ng";
-  version = "1.5.2";
+  version = "1.5.3";
 
   src = fetchFromGitHub {
     owner = "h2non";
     repo = pname;
-    rev = "v${version}";
-    sha256 = "1cxjwhx0nj85a3awnl7j6afnk07awzv45qfwxl5jqbbc9cxh5bd6";
+    # missing tag https://github.com/h2non/jsonpath-ng/issues/114
+    rev = "cce4a3d4063ac8af928795acc53beb27a2bfd101";
+    sha256 = "sha256-+9iQHQs5TQhZFeIqMlsa3FFPfZEktAWy1lSdJU7kZrc=";
   };
 
   propagatedBuildInputs = [

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

···
 }:
 
 buildPythonPackage rec {
-  version = "0.6.14.5";
+  version = "1.1.5";
   pname = "Nuitka";
 
   # Latest version is not yet on PyPi
   src = fetchFromGitHub {
-    owner = "kayhayen";
+    owner = "Nuitka";
     repo = "Nuitka";
     rev = version;
-    sha256 = "08kcp22zdgp25kk4bp56z196mn6bdi3z4x0q2y9vyz0ywfzp9zap";
+    sha256 = "0wgcl860acbxnq8q9hck147yhxz8pcbqhv9glracfnrsd2qkpgpp";
   };
 
   checkInputs = [ vmprof pyqt4 ];

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

···
+{ lib
+, stdenv
+, buildPythonPackage
+, chromium
+, ffmpeg
+, firefox
+, git
+, greenlet
+, jq
+, nodejs
+, fetchFromGitHub
+, fetchurl
+, makeFontsConf
+, makeWrapper
+, pyee
+, python
+, pythonOlder
+, runCommand
+, setuptools-scm
+, unzip
+}:
+
+let
+  inherit (stdenv.hostPlatform) system;
+  throwSystem = throw "Unsupported system: ${system}";
+
+  driverVersion = "1.27.1";
+
+  driver = let
+    suffix = {
+      x86_64-linux = "linux";
+      aarch64-linux = "linux-arm64";
+      x86_64-darwin = "mac";
+      aarch64-darwin = "mac-arm64";
+    }.${system} or throwSystem;
+    filename = "playwright-${driverVersion}-${suffix}.zip";
+  in stdenv.mkDerivation {
+    pname = "playwright-driver";
+    version = driverVersion;
+
+    src = fetchurl {
+      url = "https://playwright.azureedge.net/builds/driver/${filename}";
+      sha256 = {
+        x86_64-linux = "0x71b4kb8hlyacixipgfbgjgrbmhckxpbmrs2xk8iis7n5kg7539";
+        aarch64-linux = "125lih7g2gj91k7j196wy5a5746wyfr8idj3ng369yh5wl7lfcfv";
+        x86_64-darwin = "0z2kww4iby1izkwn6z2ai94y87bkjvwak8awdmjm8sgg00pa9l1a";
+        aarch64-darwin = "0qajh4ac5lr1sznb2c471r5c5g2r0dk2pyqz8vhvnbk36r524h1h";
+      }.${system} or throwSystem;
+    };
+
+    sourceRoot = ".";
+
+    nativeBuildInputs = [ unzip ];
+
+    postPatch = ''
+      # Use Nix's NodeJS instead of the bundled one.
+      substituteInPlace playwright.sh --replace '"$SCRIPT_PATH/node"' '"${nodejs}/bin/node"'
+      rm node
+
+      # Hard-code the script path to $out directory to avoid a dependency on coreutils
+      substituteInPlace playwright.sh \
+        --replace 'SCRIPT_PATH="$(cd "$(dirname "$0")" ; pwd -P)"' "SCRIPT_PATH=$out"
+
+      patchShebangs playwright.sh package/bin/*.sh
+    '';
+
+    installPhase = ''
+      runHook preInstall
+
+      mkdir -p $out/bin
+      mv playwright.sh $out/bin/playwright
+      mv package $out/
+
+      runHook postInstall
+    '';
+
+    passthru = {
+      inherit filename;
+    };
+  };
+
+  browsers-mac = stdenv.mkDerivation {
+    pname = "playwright-browsers";
+    version = driverVersion;
+
+    src = runCommand "playwright-browsers-base" {
+      outputHashMode = "recursive";
+      outputHashAlgo = "sha256";
+      outputHash = {
+        x86_64-darwin = "0z2kww4iby1izkwn6z2ai94y87bkjvwak8awdmjm8sgg00pa9l1a";
+      }.${system} or throwSystem;
+    } ''
+      export PLAYWRIGHT_BROWSERS_PATH=$out
+      ${driver}/bin/playwright install
+      rm -r $out/.links
+    '';
+
+    installPhase = ''
+      mkdir $out
+      cp -r * $out/
+    '';
+  };
+
+  browsers-linux = { withFirefox ? true, withChromium ? true }: let
+    fontconfig = makeFontsConf {
+      fontDirectories = [];
+    };
+  in runCommand ("playwright-browsers"
+    + lib.optionalString (withFirefox && !withChromium) "-firefox"
+    + lib.optionalString (!withFirefox && withChromium) "-chromium")
+  {
+    nativeBuildInputs = [
+      makeWrapper
+      jq
+    ];
+  } (''
+    BROWSERS_JSON=${driver}/share/playwright-driver/package/browsers.json
+  '' + lib.optionalString withChromium ''
+    CHROMIUM_REVISION=$(jq -r '.browsers[] | select(.name == "chromium").revision' $BROWSERS_JSON)
+    mkdir -p $out/chromium-$CHROMIUM_REVISION/chrome-linux
+
+    # See here for the Chrome options:
+    # https://github.com/NixOS/nixpkgs/issues/136207#issuecomment-908637738
+    makeWrapper ${chromium}/bin/chromium $out/chromium-$CHROMIUM_REVISION/chrome-linux/chrome \
+      --set SSL_CERT_FILE /etc/ssl/certs/ca-bundle.crt \
+      --set FONTCONFIG_FILE ${fontconfig}
+  '' + lib.optionalString withFirefox ''
+    FIREFOX_REVISION=$(jq -r '.browsers[] | select(.name == "firefox").revision' $BROWSERS_JSON)
+    mkdir -p $out/firefox-$FIREFOX_REVISION
+    ln -s ${firefox}/bin/firefox $out/firefox-$FIREFOX_REVISION/firefox
+  '' + ''
+    FFMPEG_REVISION=$(jq -r '.browsers[] | select(.name == "ffmpeg").revision' $BROWSERS_JSON)
+    mkdir -p $out/ffmpeg-$FFMPEG_REVISION
+    ln -s ${ffmpeg}/bin/ffmpeg $out/ffmpeg-$FFMPEG_REVISION/ffmpeg-linux
+  '');
+in
+buildPythonPackage rec {
+  pname = "playwright";
+  version = "1.27.1";
+  format = "setuptools";
+  disabled = pythonOlder "3.7";
+
+  src = fetchFromGitHub {
+    owner = "microsoft";
+    repo = "playwright-python";
+    rev = "v${version}";
+    sha256 = "sha256-cI/4GdkmTikoP9O0Skh/0jCxxRypRua0231iKcxtBcY=";
+  };
+
+  patches = [
+    # This patches two things:
+    # - The driver location, which is now a static package in the Nix store.
+    # - The setup script, which would try to download the driver package from
+    #   a CDN and patch wheels so that they include it. We don't want this
+    #   we have our own driver build.
+    ./driver-location.patch
+  ];
+
+  postPatch = ''
+    # if setuptools_scm is not listing files via git almost all python files are excluded
+    export HOME=$(mktemp -d)
+    git init .
+    git add -A .
+    git config --global user.email "nixpkgs"
+    git config --global user.name "nixpkgs"
+    git commit -m "workaround setuptools-scm"
+
+    substituteInPlace setup.py \
+      --replace "greenlet==1.1.3" "greenlet>=1.1.3" \
+      --replace "pyee==8.1.0" "pyee>=8.1.0" \
+      --replace "setuptools-scm==7.0.5" "setuptools-scm>=7.0.5" \
+      --replace "wheel==0.37.1" "wheel>=0.37.1"
+
+    # Skip trying to download and extract the driver.
+    # This is done manually in postInstall instead.
+    substituteInPlace setup.py \
+      --replace "self._download_and_extract_local_driver(base_wheel_bundles)" ""
+
+    # Set the correct driver path with the help of a patch in patches
+    substituteInPlace playwright/_impl/_driver.py \
+      --replace "@driver@" "${driver}/bin/playwright"
+  '';
+
+
+  nativeBuildInputs = [ git setuptools-scm ];
+
+  propagatedBuildInputs = [
+    greenlet
+    pyee
+  ];
+
+  postInstall = ''
+    ln -s ${driver} $out/${python.sitePackages}/playwright/driver
+  '';
+
+  # Skip tests because they require network access.
+  doCheck = false;
+
+  pythonImportsCheck = [
+    "playwright"
+  ];
+
+  passthru = {
+    inherit driver;
+    browsers = {
+      x86_64-linux = browsers-linux { };
+      aarch64-linux = browsers-linux { };
+      x86_64-darwin = browsers-mac;
+      aarch64-darwin = browsers-mac;
+    }.${system} or throwSystem;
+    browsers-chromium = browsers-linux { withFirefox = false; };
+    browsers-firefox = browsers-linux { withChromium = false; };
+  };
+
+  meta = with lib; {
+    description = "Python version of the Playwright testing and automation library";
+    homepage = "https://github.com/microsoft/playwright-python";
+    license = licenses.asl20;
+    maintainers = with maintainers; [ techknowlogick yrd SuperSandro2000 ];
+  };
+}

pkgs/development/python-modules/playwright/driver-location.patch

···
+diff --git a/playwright/_impl/_driver.py b/playwright/_impl/_driver.py
+index f3b911f..d00e509 100644
+--- a/playwright/_impl/_driver.py
++++ b/playwright/_impl/_driver.py
+@@ -23,11 +23,7 @@ from playwright._repo_version import version
+ 
+ 
+ def compute_driver_executable() -> Path:
+-    package_path = Path(inspect.getfile(playwright)).parent
+-    platform = sys.platform
+-    if platform == "win32":
+-        return package_path / "driver" / "playwright.cmd"
+-    return package_path / "driver" / "playwright.sh"
++   return Path("@driver@")
+ 
+ 
+ if sys.version_info.major == 3 and sys.version_info.minor == 7:
+diff --git a/setup.py b/setup.py
+index 3487a6a..05112c2 100644
+--- a/setup.py
++++ b/setup.py
+@@ -141,25 +141,8 @@ class PlaywrightBDistWheelCommand(BDistWheelCommand):
+         base_wheel_location: str = glob.glob(os.path.join(self.dist_dir, "*.whl"))[0]
+         without_platform = base_wheel_location[:-7]
+         for wheel_bundle in wheels:
+-            download_driver(wheel_bundle["zip_name"])
+-            zip_file = (
+-                f"driver/playwright-{driver_version}-{wheel_bundle['zip_name']}.zip"
+-            )
+-            with zipfile.ZipFile(zip_file, "r") as zip:
+-                extractall(zip, f"driver/{wheel_bundle['zip_name']}")
+             wheel_location = without_platform + wheel_bundle["wheel"]
+             shutil.copy(base_wheel_location, wheel_location)
+-            with zipfile.ZipFile(wheel_location, "a") as zip:
+-                driver_root = os.path.abspath(f"driver/{wheel_bundle['zip_name']}")
+-                for dir_path, _, files in os.walk(driver_root):
+-                    for file in files:
+-                        from_path = os.path.join(dir_path, file)
+-                        to_path = os.path.relpath(from_path, driver_root)
+-                        zip.write(from_path, f"playwright/driver/{to_path}")
+-                zip.writestr(
+-                    "playwright/driver/README.md",
+-                    f"{wheel_bundle['wheel']} driver package",
+-                )
+         os.remove(base_wheel_location)
+         if InWheel:
+             for whlfile in glob.glob(os.path.join(self.dist_dir, "*.whl")):

pkgs/development/python-modules/playwright/update.sh

···
+#!/usr/bin/env nix-shell
+#!nix-shell -i bash -p curl gnused nix-prefetch common-updater-scripts
+set -euo pipefail
+
+root="$(dirname "$(readlink -f "$0")")"
+
+version=$(curl ${GITHUB_TOKEN:+" -u \":$GITHUB_TOKEN\""} -s https://api.github.com/repos/microsoft/playwright-python/releases/latest | jq -r '.tag_name | sub("^v"; "")')
+
+# Most of the time, this should be the latest stable release of the Node-based
+# Playwright version, but that isn't a guarantee, so this needs to be specified
+# as well:
+setup_py_url="https://github.com/microsoft/playwright-python/raw/v${version}/setup.py"
+driver_version=$(curl -Ls "$setup_py_url" | grep '^driver_version =' | grep -Eo '[0-9]+\.[0-9]+\.[0-9]+')
+
+fetch_driver_arch() {
+  nix-prefetch-url "https://playwright.azureedge.net/builds/driver/playwright-${version}-${1}.zip"
+}
+
+replace_sha() {
+  sed -i "s|$1 = \".\{44,52\}\"|$1 = \"$2\"|" "$root/default.nix"
+}
+
+# Replace SHAs for the driver downloads
+replace_sha "x86_64-linux" "$(fetch_driver_arch "linux")"
+replace_sha "x86_64-darwin" "$(fetch_driver_arch "mac")"
+replace_sha "aarch64-linux" "$(fetch_driver_arch "linux-arm64")"
+replace_sha "aarch64-darwin" "$(fetch_driver_arch "mac-arm64")"
+
+# Update the version stamps
+sed -i "s/driverVersion = \"[^\$]*\"/driverVersion = \"$driver_version\"/" "$root/default.nix"
+update-source-version playwright "$version" --rev="v$version"

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

···
 
 buildPythonPackage rec {
   pname = "selenium";
-  version = "4.4.2";
+  version = "4.5.0";
   disabled = pythonOlder "3.7";
 
   src = fetchFromGitHub {
     owner = "SeleniumHQ";
     repo = "selenium";
-    rev = "refs/tags/selenium-${version}-python"; # check if there is a newer tag with -python suffix
-    hash = "sha256-sJJ3i4mnGp5fDgo64p6B2vRCqp/Wm99VoyRLyy4nBH8=";
+    # check if there is a newer tag with or without -python suffix
+    rev = "refs/tags/selenium-${version}";
+    hash = "sha256-K90CQYTeX9GKpP0ahxLx2HO5HG0P6MN7jeWmHtfiOns=";
   };
 
   postPatch = ''
···
     description = "Bindings for Selenium WebDriver";
     homepage = "https://selenium.dev/";
     license = licenses.asl20;
-    maintainers = with maintainers; [ jraygauthier ];
+    maintainers = with maintainers; [ jraygauthier SuperSandro2000 ];
   };
 }

pkgs/development/python-modules/sentry-sdk/default.nix

···
 , django
 , falcon
 , flask
-, flask_login
+, flask-login
 , httpx
 , pure-eval
 , pyramid

pkgs/development/python-modules/sqlalchemy-continuum/default.nix

···
 , fetchPypi
 , buildPythonPackage
 , flask
-, flask_login
+, flask-login
 , flask-sqlalchemy
 , flexmock
 , pytestCheckHook
···
     pytestCheckHook
     sqlalchemy-i18n
     flask
-    flask_login
+    flask-login
     flask-sqlalchemy
     flexmock
   ];

pkgs/development/r-modules/default.nix

···
     ModelMetrics = lib.optional stdenv.isDarwin pkgs.llvmPackages.openmp;
     mvabund = [ pkgs.gsl ];
     mwaved = [ pkgs.fftw.dev ];
-    mzR = with pkgs; [ zlib boost159.dev netcdf ];
+    mzR = with pkgs; [ zlib netcdf ];
     ncdf4 = [ pkgs.netcdf ];
     nloptr = with pkgs; [ nlopt pkg-config libiconv ];
     n1qn1 = [ pkgs.gfortran ];

pkgs/development/tools/oh-my-posh/default.nix

···
 
 buildGoModule rec {
   pname = "oh-my-posh";
-  version = "12.6.1";
+  version = "12.6.5";
 
   src = fetchFromGitHub {
     owner = "jandedobbeleer";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-09MLV6t062fT3P7G1pgJedzLLLuXoP+I/95WadMYLSw=";
+    sha256 = "sha256-oo3ygMdc+9Tt5hViKucLBaMatlVmmAb4QopJ9JWBJU8=";
   };
 
   vendorSha256 = "sha256-OrtKFkWXqVoXKmN6BT8YbCNjR1gRTT4gPNwmirn7fjU=";

pkgs/development/tools/rust/cauwugo/default.nix

···
+{ lib, rustPlatform, fetchCrate, installShellFiles }:
+
+rustPlatform.buildRustPackage rec {
+  pname = "cauwugo";
+  version = "0.1.0";
+
+  src = fetchCrate {
+    inherit version;
+    pname = "bpaf_cauwugo";
+    sha256 = "sha256-9gWUu2qbscKlbWZlRbOn+rrmizegkHxPnwnAmpaV1Ww=";
+  };
+
+  cargoSha256 = "sha256-dXlSBb3ey3dAiifrQ9Bbhscnm1QmcChiQbX1ic069V4=";
+
+  nativeBuildInputs = [ installShellFiles ];
+
+  postInstall = ''
+    installShellCompletion --cmd cauwugo \
+      --bash <($out/bin/cauwugo --bpaf-complete-style-bash) \
+      --fish <($out/bin/cauwugo --bpaf-complete-style-fish) \
+      --zsh  <($out/bin/cauwugo --bpaf-complete-style-zsh)
+  '';
+
+  meta = with lib; {
+    description = "An alternative cargo frontend that implements dynamic shell completion for usual cargo commands";
+    homepage = "https://github.com/pacak/bpaf/tree/master/bpaf_cauwugo";
+    license = with licenses; [ mit /* or */ asl20 ];
+    maintainers = with maintainers; [ figsoda ];
+  };
+}

pkgs/servers/consul/default.nix

···
 
 buildGoModule rec {
   pname = "consul";
-  version = "1.13.2";
+  version = "1.13.3";
   rev = "v${version}";
 
   # Note: Currently only release tags are supported, because they have the Consul UI
···
     owner = "hashicorp";
     repo = pname;
     inherit rev;
-    sha256 = "sha256-+5I5hsVuLZve4FJHe41rKycWuKNv7UdxCSi4kaKk2/w=";
+    sha256 = "sha256-pTBeR7WP25Ng1OiVkZ60wTYnSOWahkx6LYHScnX0fWw=";
   };
 
   passthru.tests.consul = nixosTests.consul;
···
   # has a split module structure in one repo
   subPackages = ["." "connect/certgen"];
 
-  vendorSha256 = "sha256-SjTG1/WhfGhLuUherVHEC3PmDz4HLMS2Cg0ReKTm0zk=";
+  vendorSha256 = "sha256-ZarkaUP9jwwP9FReaVAfPaQzKFETUEHsCsVDGFYKJvU=";
 
   doCheck = false;
 

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.29.0.6244-819d3678c";
+  version = "1.29.1.6316-f4cdfea9c";
   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";
-    sha256 = "sha256-f9QRaAF9qE3NpCt3lMWQ7MAbfLI7YQaIIF/fkJorUxY=";
+    sha256 = "sha256-FiUeZFIeXk27VQY99d2a98iBQgy7ESKd0HvYRclQHq8=";
   } else fetchurl {
     url = "https://downloads.plex.tv/plex-media-server-new/${version}/debian/plexmediaserver_${version}_amd64.deb";
-    sha256 = "sha256-iGMO6uuNm2c7UBZvA5dYaSxUrEQCL1tR9zLA3rZhBn4=";
+    sha256 = "sha256-6VSYQO6KmbAC4vlU3McF4QmuJIopBVB7aV5bpNqOSv0=";
   };
 
   outputs = [ "out" "basedb" ];

pkgs/servers/web-apps/changedetection-io/default.nix

···
+{ lib
+, fetchFromGitHub
+, python3
+}:
+let
+  py = python3.override {
+    packageOverrides = final: prev: {
+      flask = prev.flask.overridePythonAttrs (old: rec {
+        version = "2.1.3";
+        src = old.src.override {
+          inherit version;
+          sha256 = "sha256-FZcuUBffBXXD1sCQuhaLbbkCWeYgrI1+qBOjlrrVtss=";
+        };
+      });
+      flask-restful = prev.flask-restful.overridePythonAttrs (old: rec {
+        disabledTests = old.disabledTests or [ ] ++ [
+          # fails because of flask or werkzeug downgrade
+          "test_redirect"
+        ];
+      });
+      werkzeug = prev.werkzeug.overridePythonAttrs (old: rec {
+        version = "2.0.3";
+        src = old.src.override {
+          inherit version;
+          sha256 = "sha256-uGP4/wV8UiFktgZ8niiwQRYbS+W6TQ2s7qpQoWOCLTw=";
+        };
+      });
+    };
+  };
+in
+py.pkgs.buildPythonApplication rec {
+  pname = "changedetection-io";
+  version = "0.39.20.3";
+  format = "setuptools";
+
+  src = fetchFromGitHub {
+    owner = "dgtlmoon";
+    repo = "changedetection.io";
+    rev = version;
+    sha256 = "sha256-0Sv/1YoZuSnslQgMOu+uHTxb9QewXPC0tLAvzJA4Aa8=";
+  };
+
+  postPatch = ''
+    substituteInPlace requirements.txt \
+      --replace "bs4" "beautifulsoup4" \
+      --replace "cryptography ~= 3.4" "cryptography" \
+      --replace "selenium ~= 4.1.0" "selenium"
+  '';
+
+  propagatedBuildInputs = with py.pkgs; [
+    flask
+    flask-wtf
+    eventlet
+    validators
+    timeago
+    inscriptis
+    feedgen
+    flask-login
+    flask-restful
+    pytz
+    brotli
+    requests
+    urllib3
+    chardet
+    wtforms
+    jsonpath-ng
+    jq
+    apprise
+    paho-mqtt
+    cryptography
+    beautifulsoup4
+    lxml
+    selenium
+    werkzeug
+    playwright
+  ] ++ requests.optional-dependencies.socks;
+
+  # tests can currently not be run in one pytest invocation and without docker
+  doCheck = false;
+
+  checkInputs = with py.pkgs; [
+    pytest-flask
+    pytestCheckHook
+  ];
+
+  meta = with lib; {
+    homepage = "https://github.com/dgtlmoon/changedetection.io";
+    description = "Simplest self-hosted free open source website change detection tracking, monitoring and notification service";
+    license = licenses.asl20;
+    maintainers = with maintainers; [ SuperSandro2000 ];
+  };
+}

pkgs/test/cuda/cuda-samples/extension.nix

···
     "11.4" = "082dkk5y34wyvjgj2p5j1d00rk8xaxb9z0mhvz16bd469r1bw2qk";
     "11.5" = "sha256-AKRZbke0K59lakhTi8dX2cR2aBuWPZkiQxyKaZTvHrI=";
     "11.6" = "sha256-AsLNmAplfuQbXg9zt09tXAuFJ524EtTYsQuUlV1tPkE=";
-    # the tag 11.7 does not exists: see https://github.com/NVIDIA/cuda-samples/issues/128
     # maybe fixed by https://github.com/NVIDIA/cuda-samples/pull/133
-    "11.7" = throw "The tag 11.7 of cuda-samples does not exists (see see https://github.com/NVIDIA/cuda-samples/issues/128)";
+    "11.7" = throw "The tag 11.7 of cuda-samples does not exist";
+    "11.8" = throw "The tag 11.8 of cuda-samples does not exist";
   }.${prev.cudaVersion};
 
 in {

pkgs/tools/admin/credhub-cli/default.nix

···
 
 buildGoModule rec {
   pname = "credhub-cli";
-  version = "2.9.5";
+  version = "2.9.6";
 
   src = fetchFromGitHub {
     owner = "cloudfoundry-incubator";
     repo = "credhub-cli";
     rev = version;
-    sha256 = "sha256-M2FIzLl1pQ/TJinG4UOh2VQWfZx4iT3Qw6pJhjv88cM=";
+    sha256 = "sha256-g7LJlMKwV3Cq0LEBPWPgzPJAp9W6bwVuuVVv/ZhuBSM=";
   };
 
   # these tests require network access that we're not going to give them

pkgs/tools/admin/pgadmin/default.nix

···
   buildDeps = with pythonPackages; [
     flask
     flask-gravatar
-    flask_login
+    flask-login
     flask_mail
     flask_migrate
     flask-sqlalchemy

pkgs/tools/archivers/unar/default.nix

···
           --replace "= gcc" "=${stdenv.cc.targetPrefix}cc" \
           --replace "= g++" "=${stdenv.cc.targetPrefix}c++" \
           --replace "-DGNU_RUNTIME=1" "" \
-          --replace "-fgnu-runtime" "-fobjc-nonfragile-abi"
+          --replace "-fgnu-runtime" "-fobjc-runtime=gnustep-2.0"
       done
 
       # we need to build inside this directory as well, so we have to make it writeable

pkgs/tools/filesystems/lfs/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "lfs";
-  version = "2.5.0";
+  version = "2.6.0";
 
   src = fetchFromGitHub {
     owner = "Canop";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-7dSBac+rLedgko4KLVS9ZWrj/IlXJMsnbQFzyQxv4LQ=";
+    sha256 = "sha256-+BkHE4vl1oYNR5SX2y7Goly7OwGDXRoZex6YL7Xv2QI=";
   };
 
-  cargoSha256 = "sha256-stDxDBftIVZqgy49VGJHx+JTzflVE91QN75aSWhvgSs=";
+  cargoSha256 = "sha256-njrjuLHDmcubw8lLPpS9K5la0gRIKq4OrP+MXs1Ro/o=";
 
   meta = with lib; {
     description = "Get information on your mounted disks";

pkgs/tools/filesystems/netatalk/default.nix

···
-{ fetchurl, lib, stdenv, autoreconfHook, pkg-config, perl, python3
-, db, libgcrypt, avahi, libiconv, pam, openssl, acl
-, ed, libtirpc, libevent, fetchpatch
-}:
+{ fetchurl, lib, stdenv, autoreconfHook, pkg-config, perl, python3, db
+, libgcrypt, avahi, libiconv, pam, openssl, acl, ed, libtirpc, libevent
+, fetchpatch }:
 
 stdenv.mkDerivation rec {
   pname = "netatalk";
-  version = "3.1.13";
+  release = "3.1.13";
+  patch = "3";
+  version = "${release}_${patch}";
 
   src = fetchurl {
-    url = "mirror://sourceforge/netatalk/netatalk/netatalk-${version}.tar.bz2";
+    url = "mirror://sourceforge/netatalk/netatalk/netatalk-${release}.tar.bz2";
     sha256 = "0pg0slvvvq3l6f5yjz9ybijg4i6rs5a6c8wcynaasf8vzsyadbc9";
   };
 
···
     ./omitLocalstatedirCreation.patch
     (fetchpatch {
       name = "make-afpstats-python3-compatible.patch";
-      url = "https://github.com/Netatalk/Netatalk/commit/916b515705cf7ba28dc53d13202811c6e1fe6a9e.patch";
+      url =
+        "https://github.com/Netatalk/Netatalk/commit/916b515705cf7ba28dc53d13202811c6e1fe6a9e.patch";
       sha256 = "sha256-DAABpYjQPJLsQBhmtP30gA357w0Qn+AsnFgAeyDC/Rg=";
     })
   ];
 
-  nativeBuildInputs = [ autoreconfHook pkg-config perl python3 python3.pkgs.wrapPython ];
+  freeBSDPatches = [
+    # https://bugs.freebsd.org/263123
+    (fetchpatch {
+      name = "patch-etc_afpd_directory.c";
+      url =
+        "https://cgit.freebsd.org/ports/plain/net/netatalk3/files/patch-etc_afpd_directory.c";
+      sha256 = "sha256-07YAJs+EtqGcFXbYHDLbILved1Ebtd8ukQepvzy6et0=";
+    })
+    (fetchpatch {
+      name = "patch-etc_afpd_file.c";
+      url =
+        "https://cgit.freebsd.org/ports/plain/net/netatalk3/files/patch-etc_afpd_file.c";
+      sha256 = "sha256-T1WTNa2G6wxKtvMa/MCX3Vx6XZBHtU6w3enkdGuIWus=";
+    })
+    (fetchpatch {
+      name = "patch-etc_afpd_volume.c";
+      url =
+        "https://cgit.freebsd.org/ports/plain/net/netatalk3/files/patch-etc_afpd_volume.c";
+      sha256 = "sha256-NOZNZGzA0hxrNkoLTvN64h40yApPbMH4qIfBTpQoI0s=";
+    })
+    (fetchpatch {
+      name = "patch-etc_cnid__dbd_cmd__dbd__scanvol.c";
+      url =
+        "https://cgit.freebsd.org/ports/plain/net/netatalk3/files/patch-etc_cnid__dbd_cmd__dbd__scanvol.c";
+      sha256 = "sha256-5QV+tQDo8/XeKwH/e5+Ne+kEOl2uvRDbHMaWysIB6YU=";
+    })
+    (fetchpatch {
+      name = "patch-libatalk_adouble_ad__attr.c";
+      url =
+        "https://cgit.freebsd.org/ports/plain/net/netatalk3/files/patch-libatalk_adouble_ad__attr.c";
+      sha256 = "sha256-Ose6BdilwBOmoYpm8Jat1B3biOXJj4y3U4T49zE0G7Y=";
+    })
+    (fetchpatch {
+      name = "patch-libatalk_adouble_ad__conv.c";
+      url =
+        "https://cgit.freebsd.org/ports/plain/net/netatalk3/files/patch-libatalk_adouble_ad__conv.c";
+      sha256 = "sha256-T27WlKVXosv4bX5Gek2bR2cVDYEee5qrH4mnL9ghbP8=";
+    })
+    (fetchpatch {
+      name = "patch-libatalk_adouble_ad__date.c";
+      url =
+        "https://cgit.freebsd.org/ports/plain/net/netatalk3/files/patch-libatalk_adouble_ad__date.c";
+      sha256 = "sha256-fkW5A+7R5fT3bukRfZaOwFo7AsyPaYajc1hIlDMZMnc=";
+    })
+    (fetchpatch {
+      name = "patch-libatalk_adouble_ad__flush.c";
+      url =
+        "https://cgit.freebsd.org/ports/plain/net/netatalk3/files/patch-libatalk_adouble_ad__flush.c";
+      sha256 = "sha256-k2zTx35tAlsFHym83bZGoWXRomwFV9xT3r2fzr3Zvbk=";
+    })
+    (fetchpatch {
+      name = "patch-libatalk_adouble_ad__open.c";
+      url =
+        "https://cgit.freebsd.org/ports/plain/net/netatalk3/files/patch-libatalk_adouble_ad__open.c";
+      sha256 = "sha256-uV4wwft2IH54+4k5YR+Gz/BpRZBanxX/Ukp8BkohInU=";
+    })
+    # https://bugs.freebsd.org/251203
+    (fetchpatch {
+      name = "patch-libatalk_vfs_extattr.c";
+      url =
+        "https://cgit.freebsd.org/ports/plain/net/netatalk3/files/patch-libatalk_vfs_extattr.c";
+      sha256 = "sha256-lFWF0Qo8PJv7QKvnMn0Fc9Ruzb+FTEWgOMpxc789jWs=";
+    })
+  ];
+
+  postPatch = ''
+    # freeBSD patches are -p0
+    for i in $freeBSDPatches ; do
+      patch -p0 < $i
+    done
+  '';
+
+  nativeBuildInputs =
+    [ autoreconfHook pkg-config perl python3 python3.pkgs.wrapPython ];
 
   buildInputs = [ db libgcrypt avahi libiconv pam openssl acl libevent ];
 

pkgs/tools/misc/lemmeknow/default.nix

···
     description = "A tool to identify anything";
     homepage = "https://github.com/swanandx/lemmeknow";
     license = licenses.mit;
-    maintainers = with maintainers; [ figsoda ];
+    maintainers = with maintainers; [ figsoda Br1ght0ne ];
   };
 }

pkgs/tools/networking/proxify/default.nix

···
 
 buildGoModule rec {
   pname = "proxify";
-  version = "0.0.7";
+  version = "0.0.8";
 
   src = fetchFromGitHub {
     owner = "projectdiscovery";
     repo = "proxify";
     rev = "v${version}";
-    sha256 = "sha256-6YsduuiPgwxcSkqEcMxEhubte87IxWV9Qa1Vyv0Pd5w=";
+    sha256 = "sha256-0zXWW6U+x9W+fMsvYTfWRdoftsQCp2JXXkfbqS63Svk=";
   };
 
-  vendorSha256 = "sha256-ewPimn70cheToU33g3p9s0MHxQdbKiqhGReKLgiHOSI=";
+  vendorSha256 = "sha256-OldZyaPROtnPZPczFjn+kl61TI5zco/gM2MuPn2gYjo=";
 
   meta = with lib; {
     description = "Proxy tool for HTTP/HTTPS traffic capture";

pkgs/top-level/all-packages.nix

···
 
   cambalache = callPackage ../development/tools/cambalache { };
 
+  changedetection-io = callPackage ../servers/web-apps/changedetection-io { };
+
   clipster = callPackage ../tools/misc/clipster { };
 
   clockify = callPackage ../applications/office/clockify {
···
   cudaPackages_11_5 = callPackage ./cuda-packages.nix { cudaVersion = "11.5"; };
   cudaPackages_11_6 = callPackage ./cuda-packages.nix { cudaVersion = "11.6"; };
   cudaPackages_11_7 = callPackage ./cuda-packages.nix { cudaVersion = "11.7"; };
+  cudaPackages_11_8 = callPackage ./cuda-packages.nix { cudaVersion = "11.8"; };
   cudaPackages_11 = cudaPackages_11_7;
   cudaPackages = recurseIntoAttrs cudaPackages_11;
 
···
   platinum-searcher = callPackage ../tools/text/platinum-searcher { };
 
   playbar2 = libsForQt5.callPackage ../applications/audio/playbar2 { };
+
+  playwright = with python3Packages; toPythonApplication playwright;
 
   please = callPackage ../tools/security/please { };
 
···
 
   cargo-zigbuild = callPackage ../development/tools/rust/cargo-zigbuild { };
 
+  cauwugo = callPackage ../development/tools/rust/cauwugo { };
+
   crate2nix = callPackage ../development/tools/rust/crate2nix { };
 
   convco = callPackage ../development/tools/convco {
···
 
   linbox = callPackage ../development/libraries/linbox { };
 
+  ffmpeg_4-headless = callPackage ../development/libraries/ffmpeg/4.nix {
+    inherit (darwin.apple_sdk.frameworks) Cocoa CoreMedia VideoToolbox;
+
+    sdlSupport = false;
+    vdpauSupport = false;
+    pulseaudioSupport = false;
+    libva = libva-minimal;
+  };
+
   ffmpeg_4 = callPackage ../development/libraries/ffmpeg/4.nix {
     inherit (darwin.apple_sdk.frameworks) Cocoa CoreMedia VideoToolbox;
   };
+
+  ffmpeg_5-headless = callPackage ../development/libraries/ffmpeg/5.nix {
+    inherit (darwin.apple_sdk.frameworks) Cocoa CoreMedia VideoToolbox;
+
+    sdlSupport = false;
+    vdpauSupport = false;
+    pulseaudioSupport = false;
+    libva = libva-minimal;
+  };
+
   ffmpeg_5 = callPackage ../development/libraries/ffmpeg/5.nix {
     inherit (darwin.apple_sdk.frameworks) Cocoa CoreMedia VideoToolbox;
   };
···
   # Packages which use ffmpeg as a library, should pin to the relevant major
   # version number which the upstream support.
   ffmpeg = ffmpeg_4;
+
+  ffmpeg-headless = ffmpeg_4-headless;
 
   ffmpeg-full = callPackage ../development/libraries/ffmpeg-full {
     svt-av1 = if stdenv.isAarch64 then null else svt-av1;
···
     enableX11 = config.unison.enableX11 or true;
   };
 
-  unpaper = callPackage ../tools/graphics/unpaper { };
+  unpaper = callPackage ../tools/graphics/unpaper {
+    ffmpeg_5 = ffmpeg_5-headless;
+  };
 
   unison-ucm = callPackage ../development/compilers/unison { };
 
···
 
   gpio-utils = callPackage ../os-specific/linux/kernel/gpio-utils.nix { };
 
-  navidrome = callPackage ../servers/misc/navidrome {};
+  navidrome = callPackage ../servers/misc/navidrome {
+    ffmpeg = ffmpeg-headless;
+  };
 
   zalgo = callPackage ../tools/misc/zalgo { };
 

pkgs/top-level/python-aliases.nix

···
   face_recognition_models = face-recognition-models; # added 2022-10-15
   fake_factory = throw "fake_factory has been removed because it is unused and deprecated by upstream since 2016."; # added 2022-05-30
   faulthandler = throw "faulthandler is built into ${python.executable}"; # added 2021-07-12
+  flask_login = flask-login; # added 2022-10-17
   flask_sqlalchemy = flask-sqlalchemy; # added 2022-07-20
   flask_testing = flask-testing; # added 2022-04-25
   flask_wtf = flask-wtf; # added 2022-05-24

pkgs/top-level/python-packages.nix

···
 
   flask-limiter = callPackage ../development/python-modules/flask-limiter { };
 
-  flask_login = callPackage ../development/python-modules/flask-login { };
+  flask-login = callPackage ../development/python-modules/flask-login { };
 
   flask_mail = callPackage ../development/python-modules/flask-mail { };
 
···
   inotifyrecursive = callPackage ../development/python-modules/inotifyrecursive { };
 
   inquirer = callPackage ../development/python-modules/inquirer { };
+
+  inscriptis = callPackage ../development/python-modules/inscriptis { };
 
   insegel = callPackage ../development/python-modules/insegel { };
 
···
   pkginfo2 = callPackage ../development/python-modules/pkginfo2 { };
 
   pkuseg = callPackage ../development/python-modules/pkuseg { };
+
+  playwright = callPackage ../development/python-modules/playwright {
+    inherit (pkgs) jq;
+  };
 
   pmsensor = callPackage ../development/python-modules/pmsensor { };