Merge staging-next into staging

lib/attrsets.nix

···
 
 let
   inherit (builtins) head tail length;
-  inherit (lib.trivial) and;
+  inherit (lib.trivial) id;
   inherit (lib.strings) concatStringsSep sanitizeDerivationName;
-  inherit (lib.lists) foldr foldl' concatMap concatLists elemAt;
+  inherit (lib.lists) foldr foldl' concatMap concatLists elemAt all;
 in
 
 rec {
···
        getAttrFromPath ["z" "z"] x
        => error: cannot find attribute `z.z'
   */
-  getAttrFromPath = attrPath: set:
+  getAttrFromPath = attrPath:
     let errorMsg = "cannot find attribute `" + concatStringsSep "." attrPath + "'";
-    in attrByPath attrPath (abort errorMsg) set;
+    in attrByPath attrPath (abort errorMsg);
 
 
   /* Return the specified attributes from a set.
···
        foldAttrs (n: a: [n] ++ a) [] [{ a = 2; } { a = 3; }]
        => { a = [ 2 3 ]; }
   */
-  foldAttrs = op: nul: list_of_attrs:
+  foldAttrs = op: nul:
     foldr (n: a:
         foldr (name: o:
           o // { ${name} = op n.${name} (a.${name} or nul); }
         ) a (attrNames n)
-    ) {} list_of_attrs;
+    ) {};
 
 
   /* Recursively collect sets that verify a given predicate named `pred'
···
   */
   mapAttrsRecursiveCond = cond: f: set:
     let
-      recurse = path: set:
+      recurse = path:
         let
           g =
             name: value:
             if isAttrs value && cond value
               then recurse (path ++ [name]) value
               else f (path ++ [name]) value;
-        in mapAttrs g set;
+        in mapAttrs g;
     in recurse [] set;
 
 
···
       value = f name (catAttrs name sets);
     }) names);
 
-  /* Implementation note: Common names  appear multiple times in the list of
+  /* Implementation note: Common names appear multiple times in the list of
      names, hopefully this does not affect the system because the maximal
      laziness avoid computing twice the same expression and listToAttrs does
      not care about duplicated attribute names.
···
     let f = attrPath:
       zipAttrsWith (n: values:
         let here = attrPath ++ [n]; in
-        if tail values == []
-        || pred here (head (tail values)) (head values) then
+        if length values == 1
+        || pred here (elemAt values 1) (head values) then
           head values
         else
           f here values
···
        }
 
      */
-  recursiveUpdate = lhs: rhs:
-    recursiveUpdateUntil (path: lhs: rhs:
-      !(isAttrs lhs && isAttrs rhs)
-    ) lhs rhs;
+  recursiveUpdate = recursiveUpdateUntil (path: lhs: rhs: !(isAttrs lhs && isAttrs rhs));
 
   /* Returns true if the pattern is contained in the set. False otherwise.
 
···
        => true
    */
   matchAttrs = pattern: attrs: assert isAttrs pattern;
-    foldr and true (attrValues (zipAttrsWithNames (attrNames pattern) (n: values:
-      let pat = head values; val = head (tail values); in
+    all id (attrValues (zipAttrsWithNames (attrNames pattern) (n: values:
+      let pat = head values; val = elemAt values 1; in
       if length values == 1 then false
       else if isAttrs pat then isAttrs val && matchAttrs pat val
       else pat == val

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

···
           <link xlink:href="options.html#opt-services.archisteamfarm.enable">services.archisteamfarm</link>.
         </para>
       </listitem>
+      <listitem>
+        <para>
+          <link xlink:href="https://goteleport.com">teleport</link>,
+          allows engineers and security professionals to unify access
+          for SSH servers, Kubernetes clusters, web applications, and
+          databases across all environments. Available at
+          <link linkend="opt-services.teleport.enable">services.teleport</link>.
+        </para>
+      </listitem>
+      <listitem>
+        <para>
+          <link xlink:href="https://loic-sharma.github.io/BaGet/">BaGet</link>,
+          a lightweight NuGet and symbol server. Available at
+          <link linkend="opt-services.baget.enable">services.baget</link>.
+        </para>
+      </listitem>
     </itemizedlist>
   </section>
   <section xml:id="sec-release-22.05-incompatibilities">
···
           <literal>/etc/docker/daemon.json</literal>, you need to
           incorporate the changes into the new option
           <literal>virtualisation.docker.daemon.settings</literal>.
+        </para>
+      </listitem>
+      <listitem>
+        <para>
+          opensmtpd-extras is no longer build with python2 scripting
+          support due to python2 deprecation in nixpkgs
         </para>
       </listitem>
       <listitem>

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

···
 
 - [ArchiSteamFarm](https://github.com/JustArchiNET/ArchiSteamFarm), a C# application with primary purpose of idling Steam cards from multiple accounts simultaneously. Available as [services.archisteamfarm](options.html#opt-services.archisteamfarm.enable).
 
+- [teleport](https://goteleport.com), allows engineers and security professionals to unify access for SSH servers, Kubernetes clusters, web applications, and databases across all environments. Available at [services.teleport](#opt-services.teleport.enable).
+
+- [BaGet](https://loic-sharma.github.io/BaGet/), a lightweight NuGet and symbol server. Available at [services.baget](#opt-services.baget.enable).
+
 ## Backward Incompatibilities {#sec-release-22.05-incompatibilities}
 
 - `pkgs.ghc` now refers to `pkgs.targetPackages.haskellPackages.ghc`.
···
   Scripts have to be converted to Python 3 for use with `writers.writePython3` or `writers.writePyPy2` needs to be used.
 
 - If you previously used `/etc/docker/daemon.json`, you need to incorporate the changes into the new option `virtualisation.docker.daemon.settings`.
+
+- opensmtpd-extras is no longer build with python2 scripting support due to python2 deprecation in nixpkgs
 
 - The `autorestic` package has been upgraded from 1.3.0 to 1.5.0 which introduces breaking changes in config file, check [their migration guide](https://autorestic.vercel.app/migration/1.4_1.5) for more details.
 

nixos/modules/module-list.nix

···
   ./programs/zsh/zsh-autosuggestions.nix
   ./programs/zsh/zsh-syntax-highlighting.nix
   ./rename.nix
-  ./security/acme.nix
+  ./security/acme
   ./security/apparmor.nix
   ./security/audit.nix
   ./security/auditd.nix
···
   ./services/networking/tcpcrypt.nix
   ./services/networking/teamspeak3.nix
   ./services/networking/tedicross.nix
+  ./services/networking/teleport.nix
   ./services/networking/thelounge.nix
   ./services/networking/tinc.nix
   ./services/networking/tinydns.nix
···
   ./services/web-apps/bookstack.nix
   ./services/web-apps/calibre-web.nix
   ./services/web-apps/code-server.nix
+  ./services/web-apps/baget.nix
   ./services/web-apps/convos.nix
   ./services/web-apps/cryptpad.nix
   ./services/web-apps/dex.nix

nixos/modules/security/acme.nix nixos/modules/security/acme/default.nix

···
 
   meta = {
     maintainers = lib.teams.acme.members;
-    doc = ./acme.xml;
+    doc = ./doc.xml;
   };
 }

nixos/modules/security/acme/mk-cert-ownership-assertion.nix

···
+{ cert, group, groups, user }: {
+  assertion = cert.group == group || builtins.any (u: u == user) groups.${cert.group}.members;
+  message = "Group for certificate ${cert.domain} must be ${group}, or user ${user} must be a member of group ${cert.group}";
+}

nixos/modules/services/networking/teleport.nix

···
+{ config, pkgs, lib, ... }:
+
+with lib;
+
+let
+  cfg = config.services.teleport;
+  settingsYaml = pkgs.formats.yaml { };
+in
+{
+  options = {
+    services.teleport = with lib.types; {
+      enable = mkEnableOption "the Teleport service";
+
+      settings = mkOption {
+        type = settingsYaml.type;
+        default = { };
+        example = literalExpression ''
+          {
+            teleport = {
+              nodename = "client";
+              advertise_ip = "192.168.1.2";
+              auth_token = "60bdc117-8ff4-478d-95e4-9914597847eb";
+              auth_servers = [ "192.168.1.1:3025" ];
+              log.severity = "DEBUG";
+            };
+            ssh_service = {
+              enabled = true;
+              labels = {
+                role = "client";
+              };
+            };
+            proxy_service.enabled = false;
+            auth_service.enabled = false;
+          }
+        '';
+        description = ''
+          Contents of the <literal>teleport.yaml</literal> config file.
+          The <literal>--config</literal> arguments will only be passed if this set is not empty.
+
+          See <link xlink:href="https://goteleport.com/docs/setup/reference/config/"/>.
+        '';
+      };
+
+      insecure.enable = mkEnableOption ''
+        starting teleport in insecure mode.
+
+        This is dangerous!
+        Sensitive information will be logged to console and certificates will not be verified.
+        Proceed with caution!
+
+        Teleport starts with disabled certificate validation on Proxy Service, validation still occurs on Auth Service
+      '';
+
+      diag = {
+        enable = mkEnableOption ''
+          endpoints for monitoring purposes.
+
+          See <link xlink:href="https://goteleport.com/docs/setup/admin/troubleshooting/#troubleshooting/"/>
+        '';
+
+        addr = mkOption {
+          type = str;
+          default = "127.0.0.1";
+          description = "Metrics and diagnostics address.";
+        };
+
+        port = mkOption {
+          type = int;
+          default = 3000;
+          description = "Metrics and diagnostics port.";
+        };
+      };
+    };
+  };
+
+  config = mkIf config.services.teleport.enable {
+    environment.systemPackages = [ pkgs.teleport ];
+
+    systemd.services.teleport = {
+      wantedBy = [ "multi-user.target" ];
+      after = [ "network.target" ];
+      serviceConfig = {
+        ExecStart = ''
+          ${pkgs.teleport}/bin/teleport start \
+            ${optionalString cfg.insecure.enable "--insecure"} \
+            ${optionalString cfg.diag.enable "--diag-addr=${cfg.diag.addr}:${toString cfg.diag.port}"} \
+            ${optionalString (cfg.settings != { }) "--config=${settingsYaml.generate "teleport.yaml" cfg.settings}"}
+        '';
+        ExecReload = "${pkgs.coreutils}/bin/kill -HUP $MAINPID";
+        LimitNOFILE = 65536;
+        Restart = "always";
+        RestartSec = "5s";
+        RuntimeDirectory = "teleport";
+        Type = "simple";
+      };
+    };
+  };
+}
+

nixos/modules/services/system/nscd.nix

···
     systemd.services.nscd =
       { description = "Name Service Cache Daemon";
 
-        wantedBy = [ "nss-lookup.target" "nss-user-lookup.target" ];
+        before = [ "nss-lookup.target" "nss-user-lookup.target" ];
+        wants = [ "nss-lookup.target" "nss-user-lookup.target" ];
+        wantedBy = [ "multi-user.target" ];
 
         environment = { LD_LIBRARY_PATH = nssModulesPath; };
 

nixos/modules/services/web-apps/baget.nix

···
+{ config, lib, pkgs, ... }:
+
+with lib;
+
+let
+
+  cfg = config.services.baget;
+
+  defaultConfig = {
+    "PackageDeletionBehavior" = "Unlist";
+    "AllowPackageOverwrites" = false;
+
+    "Database" = {
+      "Type" = "Sqlite";
+      "ConnectionString" = "Data Source=baget.db";
+    };
+
+    "Storage" = {
+      "Type" = "FileSystem";
+      "Path" = "";
+    };
+
+    "Search" = {
+      "Type" = "Database";
+    };
+
+    "Mirror" = {
+      "Enabled" = false;
+      "PackageSource" = "https://api.nuget.org/v3/index.json";
+    };
+
+    "Logging" = {
+      "IncludeScopes" = false;
+      "Debug" = {
+        "LogLevel" = {
+          "Default" = "Warning";
+        };
+      };
+      "Console" = {
+        "LogLevel" = {
+          "Microsoft.Hosting.Lifetime" = "Information";
+          "Default" = "Warning";
+        };
+      };
+    };
+  };
+
+  configAttrs = recursiveUpdate defaultConfig cfg.extraConfig;
+
+  configFormat = pkgs.formats.json {};
+  configFile = configFormat.generate "appsettings.json" configAttrs;
+
+in
+{
+  options.services.baget = {
+    enable = mkEnableOption "BaGet NuGet-compatible server";
+
+    apiKeyFile = mkOption {
+      type = types.path;
+      example = "/root/baget.key";
+      description = ''
+        Private API key for BaGet.
+      '';
+    };
+
+    extraConfig = mkOption {
+      type = configFormat.type;
+      default = {};
+      example = {
+        "Database" = {
+          "Type" = "PostgreSql";
+          "ConnectionString" = "Server=/run/postgresql;Port=5432;";
+        };
+      };
+      defaultText = literalExpression ''
+        {
+          "PackageDeletionBehavior" = "Unlist";
+          "AllowPackageOverwrites" = false;
+
+          "Database" = {
+            "Type" = "Sqlite";
+            "ConnectionString" = "Data Source=baget.db";
+          };
+
+          "Storage" = {
+            "Type" = "FileSystem";
+            "Path" = "";
+          };
+
+          "Search" = {
+            "Type" = "Database";
+          };
+
+          "Mirror" = {
+            "Enabled" = false;
+            "PackageSource" = "https://api.nuget.org/v3/index.json";
+          };
+
+          "Logging" = {
+            "IncludeScopes" = false;
+            "Debug" = {
+              "LogLevel" = {
+                "Default" = "Warning";
+              };
+            };
+            "Console" = {
+              "LogLevel" = {
+                "Microsoft.Hosting.Lifetime" = "Information";
+                "Default" = "Warning";
+              };
+            };
+          };
+        }
+      '';
+      description = ''
+        Extra configuration options for BaGet. Refer to <link xlink:href="https://loic-sharma.github.io/BaGet/configuration/"/> for details.
+        Default value is merged with values from here.
+      '';
+    };
+  };
+
+  # implementation
+
+  config = mkIf cfg.enable {
+
+    systemd.services.baget = {
+      description = "BaGet server";
+      wantedBy = [ "multi-user.target" ];
+      wants = [ "network-online.target" ];
+      after = [ "network.target" "network-online.target" ];
+      path = [ pkgs.jq ];
+      serviceConfig = {
+        WorkingDirectory = "/var/lib/baget";
+        DynamicUser = true;
+        StateDirectory = "baget";
+        StateDirectoryMode = "0700";
+        LoadCredential = "api_key:${cfg.apiKeyFile}";
+
+        CapabilityBoundingSet = "";
+        NoNewPrivileges = true;
+        PrivateDevices = true;
+        PrivateTmp = true;
+        PrivateUsers = true;
+        PrivateMounts = true;
+        ProtectHome = true;
+        ProtectClock = true;
+        ProtectProc = "noaccess";
+        ProcSubset = "pid";
+        ProtectKernelLogs = true;
+        ProtectKernelModules = true;
+        ProtectKernelTunables = true;
+        ProtectControlGroups = true;
+        ProtectHostname = true;
+        RestrictSUIDSGID = true;
+        RestrictRealtime = true;
+        RestrictNamespaces = true;
+        LockPersonality = true;
+        RemoveIPC = true;
+        RestrictAddressFamilies = [ "AF_INET" "AF_INET6" ];
+        SystemCallFilter = [ "@system-service" "~@privileged" ];
+      };
+      script = ''
+        jq --slurpfile apiKeys <(jq -R . "$CREDENTIALS_DIRECTORY/api_key") '.ApiKey = $apiKeys[0]' ${configFile} > appsettings.json
+        ln -snf ${pkgs.baget}/lib/BaGet/wwwroot wwwroot
+        exec ${pkgs.baget}/bin/BaGet
+      '';
+    };
+
+  };
+}

nixos/modules/services/web-servers/apache-httpd/default.nix

···
       cat ${php.phpIni} > $out
       echo "$options" >> $out
     '';
+
+  mkCertOwnershipAssertion = import ../../../security/acme/mk-cert-ownership-assertion.nix;
 in
 
 
···
           `services.httpd.virtualHosts.<name>.useACMEHost` are mutually exclusive.
         '';
       }
-    ];
+    ] ++ map (name: mkCertOwnershipAssertion {
+      inherit (cfg) group user;
+      cert = config.security.acme.certs.${name};
+      groups = config.users.groups;
+    }) dependentCertNames;
 
     warnings =
       mapAttrsToList (name: hostOpts: ''

nixos/modules/services/web-servers/caddy/default.nix

···
       '';
     in
       if pkgs.stdenv.buildPlatform == pkgs.stdenv.hostPlatform then Caddyfile-formatted else Caddyfile;
+
+  acmeHosts = unique (catAttrs "useACMEHost" acmeVHosts);
+
+  mkCertOwnershipAssertion = import ../../../security/acme/mk-cert-ownership-assertion.nix;
 in
 {
   imports = [
···
       { assertion = cfg.adapter != "caddyfile" -> cfg.configFile != configFile;
         message = "Any value other than 'caddyfile' is only valid when providing your own `services.caddy.configFile`";
       }
-    ];
+    ] ++ map (name: mkCertOwnershipAssertion {
+      inherit (cfg) group user;
+      cert = config.security.acme.certs.${name};
+      groups = config.users.groups;
+    }) acmeHosts;
 
     services.caddy.extraConfig = concatMapStringsSep "\n" mkVHostConf virtualHosts;
     services.caddy.globalConfig = ''
···
 
     security.acme.certs =
       let
-        eachACMEHost = unique (catAttrs "useACMEHost" acmeVHosts);
-        reloads = map (useACMEHost: nameValuePair useACMEHost { reloadServices = [ "caddy.service" ]; }) eachACMEHost;
+        reloads = map (useACMEHost: nameValuePair useACMEHost { reloadServices = [ "caddy.service" ]; }) acmeHosts;
       in
         listToAttrs reloads;
 

nixos/modules/services/web-servers/nginx/default.nix

···
       ${user}:{PLAIN}${password}
     '') authDef)
   );
+
+  mkCertOwnershipAssertion = import ../../../security/acme/mk-cert-ownership-assertion.nix;
 in
 
 {
···
           services.nginx.virtualHosts.<name>.useACMEHost are mutually exclusive.
         '';
       }
-    ];
+    ] ++ map (name: mkCertOwnershipAssertion {
+      inherit (cfg) group user;
+      cert = config.security.acme.certs.${name};
+      groups = config.users.groups;
+    }) dependentCertNames;
 
     systemd.services.nginx = {
       description = "Nginx Web Server";

nixos/tests/acme.nix

···
     baseConfig = { nodes, config, specialConfig ? {} }: lib.mkMerge [
       {
         security.acme = {
-          defaults = (dnsConfig nodes) // {
-            inherit group;
-          };
+          defaults = (dnsConfig nodes);
           # One manual wildcard cert
           certs."example.test" = {
             domain = "*.example.test";
           };
         };
+
+        users.users."${config.services."${server}".user}".extraGroups = ["acme"];
 
         services."${server}" = {
           enable = true;
···
       } // (let
         baseCaddyConfig = { nodes, config, ... }: {
           security.acme = {
-            defaults = (dnsConfig nodes) // {
-              group = config.services.caddy.group;
-            };
+            defaults = (dnsConfig nodes);
             # One manual wildcard cert
             certs."example.test" = {
               domain = "*.example.test";
             };
           };
+
+          users.users."${config.services.caddy.user}".extraGroups = ["acme"];
 
           services.caddy = {
             enable = true;

nixos/tests/all-tests.nix

···
   systemd-unit-path = handleTest ./systemd-unit-path.nix {};
   taskserver = handleTest ./taskserver.nix {};
   telegraf = handleTest ./telegraf.nix {};
+  teleport = handleTest ./teleport.nix {};
   tiddlywiki = handleTest ./tiddlywiki.nix {};
   tigervnc = handleTest ./tigervnc.nix {};
   timezone = handleTest ./timezone.nix {};

nixos/tests/teleport.nix

···
+{ system ? builtins.currentSystem
+, config ? { }
+, pkgs ? import ../.. { inherit system config; }
+}:
+
+with import ../lib/testing-python.nix { inherit system pkgs; };
+
+let
+  minimal = { config, ... }: {
+    services.teleport.enable = true;
+  };
+
+  client = { config, ... }: {
+    services.teleport = {
+      enable = true;
+      settings = {
+        teleport = {
+          nodename = "client";
+          advertise_ip = "192.168.1.20";
+          auth_token = "8d1957b2-2ded-40e6-8297-d48156a898a9";
+          auth_servers = [ "192.168.1.10:3025" ];
+          log.severity = "DEBUG";
+        };
+        ssh_service = {
+          enabled = true;
+          labels = {
+            role = "client";
+          };
+        };
+        proxy_service.enabled = false;
+        auth_service.enabled = false;
+      };
+    };
+    networking.interfaces.eth1.ipv4.addresses = [{
+      address = "192.168.1.20";
+      prefixLength = 24;
+    }];
+  };
+
+  server = { config, ... }: {
+    services.teleport = {
+      enable = true;
+      settings = {
+        teleport = {
+          nodename = "server";
+          advertise_ip = "192.168.1.10";
+        };
+        ssh_service.enabled = true;
+        proxy_service.enabled = true;
+        auth_service = {
+          enabled = true;
+          tokens = [ "node:8d1957b2-2ded-40e6-8297-d48156a898a9" ];
+        };
+      };
+      diag.enable = true;
+      insecure.enable = true;
+    };
+    networking = {
+      firewall.allowedTCPPorts = [ 3025 ];
+      interfaces.eth1.ipv4.addresses = [{
+        address = "192.168.1.10";
+        prefixLength = 24;
+      }];
+    };
+  };
+in
+{
+  minimal = makeTest {
+    # minimal setup should always work
+    name = "teleport-minimal-setup";
+    meta.maintainers = with pkgs.lib.maintainers; [ ymatsiuk ];
+    nodes = { inherit minimal; };
+
+    testScript = ''
+      minimal.wait_for_open_port("3025")
+      minimal.wait_for_open_port("3080")
+      minimal.wait_for_open_port("3022")
+    '';
+  };
+
+  basic = makeTest {
+    # basic server and client test
+    name = "teleport-server-client";
+    meta.maintainers = with pkgs.lib.maintainers; [ ymatsiuk ];
+    nodes = { inherit server client; };
+
+    testScript = ''
+      with subtest("teleport ready"):
+          server.wait_for_open_port("3025")
+          client.wait_for_open_port("3022")
+
+      with subtest("check applied configuration"):
+          server.wait_until_succeeds("tctl get nodes --format=json | ${pkgs.jq}/bin/jq -e '.[] | select(.spec.hostname==\"client\") | .metadata.labels.role==\"client\"'")
+          server.wait_for_open_port("3000")
+          client.succeed("journalctl -u teleport.service --grep='DEBU'")
+          server.succeed("journalctl -u teleport.service --grep='Starting teleport in insecure mode.'")
+    '';
+  };
+}

pkgs/applications/misc/octoprint/plugins.nix

···
 
   costestimation = buildPlugin rec {
     pname = "CostEstimation";
-    version = "3.3.0";
+    version = "3.4.0";
 
     src = fetchFromGitHub {
       owner = "OllisGit";
       repo = "OctoPrint-${pname}";
       rev = version;
-      sha256 = "sha256-d7miGMCNJD0siaZb6EnoMZCkKot7vnZjxNZX2TunJcs=";
+      sha256 = "sha256-04OPa/RpM8WehUmOp195ocsAjAvKdVY7iD5ybzQO7Dg=";
     };
 
     meta = with lib; {

pkgs/applications/misc/spicetify-cli/default.nix

···
 
 buildGoModule rec {
   pname = "spicetify-cli";
-  version = "2.8.3";
+  version = "2.8.4";
 
   src = fetchFromGitHub {
     owner = "khanhas";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-Ht+EDCoPn1dA8VHTEiq5xPm34lcsiug8jQHvQdCG2yg=";
+    sha256 = "sha256-WsNiMlqr9ya06Urvw/m3yPsGLCTOvYFaO0oNHuVKNTs=";
   };
 
   vendorSha256 = "sha256-g0RYIVIq4oMXdRZDBDnVYg7ombN5WEo/6O9hChQvOYs=";

pkgs/applications/networking/mailreaders/notmuch/default.nix

···
     sha256 = "wfLO7kf2iXESItcgWvKj/npKnYwy5OCyStZviN9qR9M=";
   };
 
+  patches = [
+    # https://nmbug.notmuchmail.org/nmweb/show/87o84iza9r.fsf%40starbuck.i-did-not-set--mail-host-address--so-tickle-me
+    ./test-fix-support-for-gpgsm-in-gnupg-2.3.patch
+  ];
+
   nativeBuildInputs = [
     pkg-config
     doxygen                   # (optional) api docs

pkgs/applications/networking/mailreaders/notmuch/test-fix-support-for-gpgsm-in-gnupg-2.3.patch

···
+From a642ad542e3d3f34e949c5c66923ca8a6e6cbbd8 Mon Sep 17 00:00:00 2001
+From: Stig Palmquist <[e-mail]>
+Date: Tue, 11 Jan 2022 13:23:13 +0100
+Subject: [PATCH] test: fix support for gpgsm in gnupg 2.3
+
+gpgsm --list-keys output changed the label for fingerprints from
+"fingerprint: " to "sha[12] fpr: " breaking tests with gnupg 2.3. this
+adds support for both.
+---
+ test/test-lib.sh | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+diff --git a/test/test-lib.sh b/test/test-lib.sh
+index 6bc0b723..3de608f9 100644
+--- a/test/test-lib.sh
++++ b/test/test-lib.sh
+@@ -145,7 +145,7 @@ add_gpgsm_home () {
+     mkdir -p -m 0700 "$GNUPGHOME"
+     gpgsm --batch --no-tty --no-common-certs-import --pinentry-mode=loopback --passphrase-fd 3 \
+ 	  --disable-dirmngr --import  >"$GNUPGHOME"/import.log 2>&1 3<<<'' <$NOTMUCH_SRCDIR/test/smime/0xE0972A47.p12
+-    fpr=$(gpgsm --batch --list-key [e-mail] | sed -n 's/.*fingerprint: //p')
++    fpr=$(gpgsm --batch --list-key [e-mail] | sed -n 's/.*\(fingerprint\|sha1 fpr\): //p')
+     echo "$fpr S relax" >> "$GNUPGHOME/trustlist.txt"
+     gpgsm --quiet --batch --no-tty --no-common-certs-import --disable-dirmngr --import < $NOTMUCH_SRCDIR/test/smime/ca.crt
+     echo "4D:E0:FF:63:C0:E9:EC:01:29:11:C8:7A:EE:DA:3A:9A:7F:6E:C1:0D S" >> "$GNUPGHOME/trustlist.txt"
+-- 
+2.34.1
+

pkgs/applications/radio/gqrx/default.nix

···
 
 gnuradio3_8Minimal.pkgs.mkDerivation rec {
   pname = "gqrx";
-  version = "2.15.1";
+  version = "2.15.2";
 
   src = fetchFromGitHub {
     owner = "gqrx-sdr";
     repo = "gqrx";
     rev = "v${version}";
-    sha256 = "sha256-OL83l3A27rggfGbfLT1CUaPAQHEKXgoGS1jYJZ9eHPQ=";
+    sha256 = "sha256-LWuSJbzQKHoCbkyRQ7KqUxFXzA99kuafPibH8Xx7mXs=";
   };
 
   nativeBuildInputs = [

pkgs/applications/video/go-chromecast/default.nix

···
 
 buildGoModule rec {
   pname = "go-chromecast";
-  version = "0.2.10";
+  version = "0.2.11";
 
   src = fetchFromGitHub {
     owner = "vishen";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-8216YaDgjy9Fp94Y5SQwEQpAP4NwvEhsJHe6xpQLAk8=";
+    sha256 = "sha256-BCOyeXo3uoR4ry/nFbF+//U62/hHnPK+tbG+8Rv6Rv0=";
   };
 
   vendorSha256 = "sha256-idxElk4Sy7SE9G1OMRw8YH4o8orBa80qhBXPA+ar620=";

pkgs/applications/virtualization/cloud-hypervisor/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "cloud-hypervisor";
-  version = "20.1";
+  version = "20.2";
 
   src = fetchFromGitHub {
     owner = "cloud-hypervisor";
     repo = pname;
     rev = "v${version}";
-    sha256 = "1r55ykxwa0xr1f9sp7mnv8nqf0dr7vw62b1w8r7mmyrndwnq6z5b";
+    sha256 = "sha256-yIp1p8GyBojWKmvFRZ/OeyF2bjlqYsuXUrYTVunYV8Y=";
   };
 
   nativeBuildInputs = [ pkg-config ];
   buildInputs = [ openssl ] ++ lib.optional stdenv.isAarch64 dtc;
 
-  cargoSha256 = "07wpfhlp82hp3hr8vc52vhkrxd8xpyvdvfqh1dn1fnhxk3b1z7lz";
+  cargoSha256 = "sha256-s2u6e2JbukPo3pXYzQJXP5d2G213u1+1ke9gZFnB+5g=";
 
   meta = with lib; {
     homepage = "https://github.com/cloud-hypervisor/cloud-hypervisor";

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

···
 
 stdenv.mkDerivation rec {
   pname = "gnome-software";
-  version = "41.2";
+  version = "41.3";
 
   src = fetchurl {
     url = "mirror://gnome/sources/gnome-software/${lib.versions.major version}/${pname}-${version}.tar.xz";
-    sha256 = "OErdrMh4QlOoeXGBSweS+9LJQfpEiw+UOLv1dJgszBc=";
+    sha256 = "ZQVjN3q2mxAQXfdxuz8hY3lVO7evQISNjDBljgEAmLw=";
   };
 
   patches = [

pkgs/development/libraries/gbenchmark/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "gbenchmark";
-  version = "1.6.0";
+  version = "1.6.1";
 
   src = fetchFromGitHub {
     owner = "google";
     repo = "benchmark";
     rev = "v${version}";
-    sha256 = "sha256-EAJk3JhLdkuGKRMtspTLejck8doWPd7Z0Lv/Mvf3KFY=";
+    sha256 = "sha256-yUiFxi80FWBmTZgqmqTMf9oqcBeg3o4I4vKd4djyRWY=";
   };
 
   nativeBuildInputs = [ cmake ];

pkgs/development/libraries/liburing/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "liburing";
-  version = "2.1";
+  version = "2.1"; # remove patch when updating
 
   src = fetchgit {
     url    = "http://git.kernel.dk/${pname}";
···
   '' + lib.optionalString stdenv.hostPlatform.isGnu ''
     cp ./examples/ucontext-cp $bin/bin/io_uring-ucontext-cp
   '';
+
+  # fix for compilation on 32-bit ARM, merged by upstream but not released; remove when
+  # upstream releases an update
+  patches = lib.optional stdenv.isAarch32 [
+    (fetchpatch {
+      url = "https://github.com/axboe/liburing/commit/e75a6cfa085fc9b5dbf5140fc1efb5a07b6b829e.diff";
+      sha256 = "sha256-qQEQXYm5mkws2klLxwuuoPSPRkpP1s6tuylAAEp7+9E=";
+    })
+  ];
 
   meta = with lib; {
     description = "Userspace library for the Linux io_uring API";

pkgs/development/libraries/umockdev/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "umockdev";
-  version = "0.17.1";
+  version = "0.17.2";
 
   outputs = [ "bin" "out" "dev" "devdoc" ];
 
   src = fetchurl {
     url = "https://github.com/martinpitt/umockdev/releases/download/${version}/${pname}-${version}.tar.xz";
-    sha256 = "sha256-lq8lVQlSZpFGDL7nGV8pPe+AClK8PjzWoPmhfWvHpJs=";
+    sha256 = "sha256-D9Kb67HACi8guMoT5n3Yp9INigjuuGAIyKMgcICBJmA=";
   };
 
   nativeBuildInputs = [

pkgs/development/libraries/xgboost/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "xgboost";
-  version = "1.5.0";
+  version = "1.5.1";
 
   src = fetchFromGitHub {
     owner = "dmlc";
     repo = pname;
     rev = "v${version}";
     fetchSubmodules = true;
-    sha256 = "sha256-xrRKpZ6NSBtEL2CBN7KggDwIvQKIPD8EBlA0oCJv8mw=";
+    sha256 = "sha256-WvYMfJYDF4azXkz2tBI9R9EpSOhFxpEja4RLuAfYAtE=";
   };
 
   nativeBuildInputs = [ cmake ] ++ lib.optional stdenv.isDarwin llvmPackages.openmp;

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

···
 
 buildPythonPackage rec {
   pname = "gitpython";
-  version = "3.1.24";
+  version = "3.1.25";
   disabled = pythonOlder "3.7";
 
   src = fetchFromGitHub {
     owner = "gitpython-developers";
     repo = "GitPython";
     rev = version;
-    sha256 = "sha256-KfR14EqXsDgIZUerk/hHDB0Z7IuqncbTNd/yNwrV9I0=";
+    sha256 = "sha256-ienc7zvLe6t8rkMtC6wVIewUqQBFdFbLc8iPT6aPVrE=";
   };
 
   patches = [

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

···
 
 buildPythonPackage rec {
   pname = "aiocurrencylayer";
-  version = "1.0.2";
+  version = "1.0.3";
   format = "pyproject";
 
   disabled = pythonOlder "3.8";
···
     owner = "home-assistant-ecosystem";
     repo = pname;
     rev = version;
-    sha256 = "EVqnrMatOk2I6hiCkiT5FOWvMY9LEK8LlSHqi0x9kuQ=";
+    sha256 = "sha256-t2Pcoakk25vtUYajIZVITsrEUSdwwiA3fbdswy3n9P8=";
   };
 
   nativeBuildInputs = [

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

···
 { lib
 
 , buildPythonPackage
+, fetchpatch
 , fetchPypi
+, pythonAtLeast
 , pythonOlder
 , typing-extensions
 , coverage
···
     inherit pname version;
     sha256 = "8b02facfbc9b0f1867739949a223f3d3267ed8663691cc95abd94e2c1d8c2b46";
   };
+
+  patches = lib.optionals (pythonAtLeast "3.10") [
+    (fetchpatch {
+      # Fix TypeError: wait() got an unexpected keyword argument 'loop'
+      # See https://github.com/omnilib/aioitertools/issues/84
+      url = "https://raw.githubusercontent.com/archlinux/svntogit-community/packages/python-aioitertools/trunk/python310.patch";
+      sha256 = "sha256-F10sduGaLBcxEoP83N/lGpZIlzkM2JTnQnhHKFwc7P0=";
+    })
+  ];
 
   propagatedBuildInputs = [ typing-extensions ];
   checkInputs = [ coverage toml ];

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

···
 
 buildPythonPackage rec {
   pname = "aioridwell";
-  version = "2021.10.0";
+  version = "2021.12.2";
   format = "pyproject";
 
   disabled = pythonOlder "3.8";
···
     owner = "bachya";
     repo = pname;
     rev = version;
-    sha256 = "sha256-h89gfdZvk7H22xAczaPMscTYZu0YeFxvFfL6/Oz2cJw=";
+    sha256 = "sha256-QFUXWleHRMBgaRsMNt2xFb3XcbCNI2kKQHKCBrUuG6Q=";
   };
 
   nativeBuildInputs = [

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

···
 
 buildPythonPackage rec {
   pname = "bleak";
-  version = "0.13.0";
+  version = "0.14.0";
 
   disabled = !isPy3k;
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "1vnwk36qfws9amqrdaynf63dcj2gzxm0ns1l75hrczmd5j2ic1zb";
+    sha256 = "b449cc63f769c2d219c67e23ffb9f3a5b5f23eb2d68d05878743dbed83a14360";
   };
 
   postPatch = ''

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

···
-{ lib, stdenv, buildPythonPackage, fetchPypi, isPy3k
+{ lib
+, stdenv
+, buildPythonPackage
+, cheroot
+, fetchPypi
+, jaraco_collections
+, more-itertools
+, objgraph
+, pathpy
+, portend
+, pytest-forked
+, pytest-services
+, pytestCheckHook
+, pythonAtLeast
+, pythonOlder
+, requests-toolbelt
+, routes
 , setuptools-scm
-, cheroot, portend, more-itertools, zc_lockfile, routes
-, jaraco_collections
-, objgraph, pytest, pytest-cov, pathpy, requests-toolbelt, pytest-services
-, fetchpatch
+, simplejson
+, zc_lockfile
 }:
 
 buildPythonPackage rec {
   pname = "cherrypy";
-  version = "18.6.0";
+  version = "18.6.1";
+  format = "setuptools";
 
-  disabled = !isPy3k;
+  disabled = pythonOlder "3.7";
 
   src = fetchPypi {
     pname = "CherryPy";
     inherit version;
-    sha256 = "16f410izp2c4qhn4n3l5l3qirmkf43h2amjqms8hkl0shgfqwq2n";
+    hash = "sha256-8z6HKG57PjCeBOciXY5JOC2dd3PmCSJB1/YTiTxWNJU=";
   };
 
-  patches = [
-    # 1/3 Fix compatibility with pytest 6. Will be part of the next release after 18.6
-    (fetchpatch {
-      url = "https://github.com/cherrypy/cherrypy/pull/1897/commits/59c0e19d7df8680e36afc96756dce72435121448.patch";
-      sha256 = "1jachbvp505gndccdhny0c3grzdrmvmbzq4kw55jx93ay94ni6p0";
-    })
-    # 2/3 Fix compatibility with pytest 6. Will be part of the next release after 18.6
-    (fetchpatch {
-      url = "https://github.com/cherrypy/cherrypy/pull/1897/commits/4a6287b73539adcb7b0ae72d69644a1ced1f7eaa.patch";
-      sha256 = "0nz40qmgxknkbjsdzfzcqfxdsmsxx3v104fb0h04yvs76mqvw3i4";
-    })
-    # 3/3 Fix compatibility with pytest 6. Will be part of the next release after 18.6
-    (fetchpatch {
-      url = "https://github.com/cherrypy/cherrypy/commit/3bae7f06868553b006915f05ff14d86163f59a7d.patch";
-      sha256 = "1z0bv23ybyw87rf1i8alsdi3gc2bzmdj9d0kjsghdkvi3zdp4n8q";
-    })
+  nativeBuildInputs = [
+    setuptools-scm
   ];
 
-  nativeBuildInputs = [ setuptools-scm ];
-
   propagatedBuildInputs = [
     # required
-    cheroot portend more-itertools zc_lockfile
+    cheroot
+    portend
+    more-itertools
+    zc_lockfile
     jaraco_collections
     # optional
     routes
+    simplejson
   ];
 
   checkInputs = [
-    objgraph pytest pytest-cov pathpy requests-toolbelt pytest-services
+    objgraph
+    pathpy
+    pytest-forked
+    pytest-services
+    pytestCheckHook
+    requests-toolbelt
   ];
 
-  # Keyboard interrupt ends test suite run
-  # daemonize and autoreload tests have issue with sockets within sandbox
-  # Disable doctest plugin because times out
-  checkPhase = ''
-    substituteInPlace pytest.ini --replace "--doctest-modules" ""
-    pytest \
-      -k 'not KeyboardInterrupt and not daemonize and not Autoreload' \
-      --deselect=cherrypy/test/test_static.py::StaticTest::test_null_bytes \
-      --deselect=cherrypy/test/test_tools.py::ToolTests::testCombinedTools \
-      ${lib.optionalString stdenv.isDarwin
-        "--deselect=cherrypy/test/test_bus.py::BusMethodTests::test_block --deselect=cherrypy/test/test_config_server.py"}
+  preCheck = ''
+    # Disable doctest plugin because times out
+    substituteInPlace pytest.ini \
+      --replace "--doctest-modules" "-vvv"
+    sed -i "/--cov/d" pytest.ini
   '';
 
+  pytestFlagsArray = [
+    "-W"
+    "ignore::DeprecationWarning"
+  ];
+
+  disabledTests = [
+    # Keyboard interrupt ends test suite run
+    "KeyboardInterrupt"
+    # daemonize and autoreload tests have issue with sockets within sandbox
+    "daemonize"
+    "Autoreload"
+  ] ++ lib.optionals stdenv.isDarwin [
+    "test_block"
+  ];
+
+  disabledTestPaths = lib.optionals stdenv.isDarwin [
+    "cherrypy/test/test_config_server.py"
+  ];
+
   __darwinAllowLocalNetworking = true;
 
+  pythonImportsCheck = [
+    "cherrypy"
+  ];
+
   meta = with lib; {
+    description = "Object-oriented HTTP framework";
     homepage = "https://www.cherrypy.org";
-    description = "A pythonic, object-oriented HTTP framework";
     license = licenses.bsd3;
+    maintainers = with maintainers; [ ];
   };
 }

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

···
 
 buildPythonPackage rec {
   pname = "chiavdf";
-  version = "1.0.3";
+  version = "1.0.4";
   disabled = pythonOlder "3.7";
 
   src = fetchPypi {
     inherit pname version;
-    hash = "sha256-XbmK7ZJnUy3Zg9XWt0t/Qb2k5qIlu4vIbxdDFYFjFPI=";
+    hash = "sha256-i6ylxtw1dMtylS4m0mz6rATU1trbMpcmsB2WhD++CeM=";
   };
 
   patches = [

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

···
 
 buildPythonPackage rec {
   pname = "datadog";
-  version = "0.42.0";
+  version = "0.43.0";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "sha256-em+sF6fQnxiDq5pFzk/3oWqhpes8xMbN2sf4xT59Hps=";
+    sha256 = "1f2123083d9e1add6f238c62714b76ac2fc134d7d1c435cd82b976487b191b96";
   };
 
   postPatch = ''

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

···
 buildPythonPackage rec {
   pname = "denonavr";
   version = "0.10.9";
+  format = "setuptools";
+
   disabled = pythonOlder "3.6";
 
   src = fetchFromGitHub {
···
     pytest-timeout
   ];
 
-  pythonImportsCheck = [ "denonavr" ];
+  disabledTestPaths = [
+    # https://github.com/ol-iver/denonavr/issues/228
+    "tests/test_denonavr.py"
+  ];
+
+  pythonImportsCheck = [
+    "denonavr"
+  ];
 
   meta = with lib; {
     description = "Automation Library for Denon AVR receivers";

pkgs/development/python-modules/devolo-plc-api/default.nix

···
 { lib
 , buildPythonPackage
 , fetchFromGitHub
+, fetchpatch
 , httpx
 , protobuf
 , pytest-asyncio
···
 
 buildPythonPackage rec {
   pname = "devolo-plc-api";
-  version = "0.7.0";
+  version = "0.7.1";
   format = "setuptools";
 
   disabled = pythonOlder "3.8";
···
     owner = "2Fake";
     repo = "devolo_plc_api";
     rev = "v${version}";
-    sha256 = "sha256-qzjH52bKQ/oSFd580V92uE2/Z2g+2nLh/JXOXYqVfSY=";
+    sha256 = "sha256-XR/daDrnfbLBrUTTMFYtndr6+RxPwnF4qbXAdXsXKHk=";
   };
 
   SETUPTOOLS_SCM_PRETEND_VERSION = version;
···
     zeroconf
   ];
 
-
   checkInputs = [
     pytest-asyncio
     pytest-httpx
     pytest-mock
     pytestCheckHook
   ];
+
+
 
   pythonImportsCheck = [
     "devolo_plc_api"

pkgs/development/python-modules/django-taggit/default.nix

···
 
 buildPythonPackage rec {
   pname = "django-taggit";
-  version = "1.5.1";
+  version = "2.0.0";
   format = "setuptools";
   disabled = pythonOlder "3.6";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "e5bb62891f458d55332e36a32e19c08d20142c43f74bc5656c803f8af25c084a";
+    sha256 = "a23ca776ee2709b455c3a95625be1e4b891ddf1ffb4173153c41806de4038d72";
   };
 
   propagatedBuildInputs = [

pkgs/development/python-modules/flux-led/default.nix

···
 
 buildPythonPackage rec {
   pname = "flux-led";
-  version = "0.27.44";
+  version = "0.27.45";
   format = "setuptools";
 
   disabled = pythonOlder "3.7";
···
     owner = "Danielhiversen";
     repo = "flux_led";
     rev = version;
-    sha256 = "sha256-ImtXcT6CxW6bhtL4uJM8PAvQOm36pxgTGZp4BCJXTUQ=";
+    sha256 = "sha256-0MKcPDn9Jtp7bEbusOHforEBOkM+y0TUG72Ynt5rdfg=";
   };
 
   propagatedBuildInputs = [

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

···
 
 buildPythonPackage rec {
   pname = "formbox";
-  version = "0.1.0";
+  version = "0.3.0";
   format = "flit";
-  disabled = pythonOlder "3.7";
+  disabled = pythonOlder "3.6";
 
   src = fetchFromSourcehut {
     owner = "~cnx";
     repo = pname;
     rev = version;
-    sha256 = "sha256-6OzmYqUC3mmrAMeMExI4rdVGUoWrxRuBfjKFYbHUlgE=";
+    sha256 = "sha256-K8NqMi80UurirAZaw67nhW5hFC3+dbdoT84hW7iIcaM=";
   };
 
   propagatedBuildInputs = [ bleach markdown ];

pkgs/development/python-modules/glances-api/default.nix

···
 
 buildPythonPackage rec {
   pname = "glances-api";
-  version = "0.3.2";
+  version = "0.3.3";
   format = "pyproject";
 
   disabled = pythonOlder "3.8";
···
     owner = "home-assistant-ecosystem";
     repo = "python-glances-api";
     rev = version;
-    sha256 = "sha256-zVK63SI8ZeVrY2iEEkgp8pq6RDheKeApb9/RWgZCKGI=";
+    sha256 = "sha256-F3jmYBZNzI4hRmH1J+S5RwxjouZNcUJOnD3QpX1J39s=";
   };
 
   nativeBuildInputs = [

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

···
 }:
 
 buildPythonPackage rec {
-  version = "1.0.0";
+  version = "1.1.1";
   pname = "grappelli_safe";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "84c03ec5373341d980a76480d992389e286fbc50048e91bc2e5c876d02873cc5";
+    sha256 = "ee34b3e2a3711498b1f8da3d9daa8a1239efdf255a212181742b6a5890fac039";
   };
 
   meta = with lib; {

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

···
 
 buildPythonPackage rec {
   pname = "hahomematic";
-  version = "0.17.1";
+  version = "0.18.0";
   format = "setuptools";
 
   disabled = pythonOlder "3.9";
···
     owner = "danielperna84";
     repo = pname;
     rev = version;
-    sha256 = "sha256-Nhl2WLrqqvGaNEgJApcgZhSm4xoq62MzJC0MfEO5Xxw=";
+    sha256 = "sha256-SkEI5uWKtszSBZblDBvbEmJh0OdvqDcwY6PG3JK4djY=";
   };
 
   propagatedBuildInputs = [

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

···
 
 buildPythonPackage rec {
   pname = "holidays";
-  version = "0.11.3.1";
+  version = "0.12";
   format = "setuptools";
 
   disabled = pythonOlder "3.6";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "sha256-SFWv4Ov0KO+8+EhHeCi4ifhRW+f08VriZoKRk2nZJ3Q=";
+    sha256 = "d99f2b6ddc5bfab7b7f8bbed457a82104f8980122a04b982bfc0e4f8820a1d46";
   };
 
   propagatedBuildInputs = [

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

···
 
 buildPythonPackage rec {
   pname = "idasen";
-  version = "0.8.1";
+  version = "0.8.2";
   format = "pyproject";
 
   disabled = pythonOlder "3.8";
···
     owner = "newAM";
     repo = "idasen";
     rev = "v${version}";
-    sha256 = "122bhbc3zqqm4x1x7a7mydvxxjrdssnqyxyqg0lbgxgn5rm8wbdd";
+    sha256 = "sha256-s8CnYMUVl2VbGbVxICSaKH5DxTA+NP/zPX1z7vfMqi4=";
   };
 
   nativeBuildInputs = [

pkgs/development/python-modules/json-tricks/default.nix

···
+{ lib
+, fetchFromGitHub
+, buildPythonPackage
+, pythonOlder
+, pytestCheckHook
+, numpy
+, pandas
+, pytz
+}:
+
+buildPythonPackage rec {
+  pname = "json-tricks";
+  version = "3.15.5";
+  disabled = pythonOlder "3.5";
+
+  src = fetchFromGitHub {
+    owner = "mverleg";
+    repo = "pyjson_tricks";
+    rev = "v${version}";
+    sha256 = "wdpqCqMO0EzKyqE4ishL3CTsSw3sZPGvJ0HEktKFgZU=";
+  };
+
+  checkInputs = [ numpy pandas pytz pytestCheckHook ];
+
+  pythonImportsCheck = [ "json_tricks" ];
+
+  meta = with lib; {
+    description = "Extra features for Python JSON handling";
+    homepage = "https://github.com/mverleg/pyjson_tricks";
+    license = licenses.bsd3;
+    maintainers = with maintainers; [ bcdarwin ];
+  };
+}

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

···
 
   postPatch = ''
     sed -i "s/==.*//g" requirements/test.txt
+
+    substituteInPlace requirements/base.txt --replace 'PyYAML>=3.13,<6' 'PyYAML>=3.13'
   '';
 
   propagatedBuildInputs = [ pyyaml ];

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

···
 
 buildPythonPackage rec {
   pname = "limiter";
-  version = "0.1.2";
+  version = "0.2.0";
+  format = "setuptools";
 
-  disabled = pythonOlder "3.7";
+  disabled = pythonOlder "3.10";
 
   src = fetchFromGitHub {
     owner = "alexdelorenzo";
     repo = pname;
     rev = "v${version}";
-    sha256 = "0cdqw08qw3cid1yjknlh4hqfl46xh4madkjrl7sxk2c1pbwils8r";
+    hash = "sha256-h3XiCR/8rcCBwdhO6ExrrUE9piba5mssad3+t41scSk=";
   };
 
   propagatedBuildInputs = [

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

···
 { lib
 , stdenv
+, aiocontextvars
 , buildPythonPackage
-, fetchPypi
-, fetchpatch
-, isPy27
 , colorama
+, fetchpatch
+, fetchPypi
 , pytestCheckHook
+, pythonOlder
 }:
 
 buildPythonPackage rec {
   pname = "loguru";
   version = "0.5.3";
+  format = "setuptools";
 
-  disabled = isPy27;
+  disabled = pythonOlder "3.5";
 
   src = fetchPypi {
     inherit pname version;
     sha256 = "b28e72ac7a98be3d28ad28570299a393dfcd32e5e3f6a353dec94675767b6319";
   };
 
+  propagatedBuildInputs = lib.optionals (pythonOlder "3.7") [
+    aiocontextvars
+  ];
+
+  checkInputs = [
+    pytestCheckHook
+    colorama
+  ];
+
   patches = [
     # Fixes tests with pytest>=6.2.2. Will be part of the next release after 0.5.3
     (fetchpatch {
       url = "https://github.com/Delgan/loguru/commit/31cf758ee9d22dbfa125f38153782fe20ac9dce5.patch";
       sha256 = "1lzbs8akg1s7s6xjl3samf4c4bpssqvwg5fn3mwlm4ysr7jd5y67";
     })
-    # fix tests with Python 3.9
+    # Fix tests with Python 3.9
     (fetchpatch {
       url = "https://github.com/Delgan/loguru/commit/19f518c5f1f355703ffc4ee62f0e1e397605863e.patch";
       sha256 = "0yn6smik58wdffr4svqsy2n212fwdlcfcwpgqhl9hq2zlivmsdc6";
     })
   ];
 
-  checkInputs = [ pytestCheckHook colorama ];
+  disabledTestPaths = lib.optionals stdenv.isDarwin [
+    "tests/test_multiprocessing.py"
+  ];
 
-  disabledTestPaths = lib.optionals stdenv.isDarwin [ "tests/test_multiprocessing.py" ];
-  disabledTests = [ "test_time_rotation_reopening" "test_file_buffering" ]
-    ++ lib.optionals stdenv.isDarwin [ "test_rotation_and_retention" "test_rotation_and_retention_timed_file" "test_renaming" "test_await_complete_inheritance" ];
+  disabledTests = [
+    "test_time_rotation_reopening"
+    "test_file_buffering"
+    # Tests are failing with Python 3.10
+    "test_exception_others"
+    ""
+  ] ++ lib.optionals stdenv.isDarwin [
+    "test_rotation_and_retention"
+    "test_rotation_and_retention_timed_file"
+    "test_renaming"
+    "test_await_complete_inheritance"
+  ];
+
+  pythonImportsCheck = [
+    "loguru"
+  ];
 
   meta = with lib; {
     homepage = "https://github.com/Delgan/loguru";

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

···
 
 buildPythonPackage rec {
   pname = "luftdaten";
-  version = "0.7.1";
+  version = "0.7.2";
   format = "pyproject";
 
   disabled = pythonOlder "3.8";
···
     owner = "home-assistant-ecosystem";
     repo = "python-luftdaten";
     rev = version;
-    sha256 = "sha256-76Y5TJet0WtzYXuK8Og0rmpsUIlXK7b37oesh+MliU8=";
+    sha256 = "sha256-tYaY/F4mdO5k+Oj+RkNFWP8xqh1xuDyoAKBFzAhamkA=";
   };
 
   nativeBuildInputs = [

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

···
 
 buildPythonPackage rec {
   pname = "luxtronik";
-  version = "0.3.9";
+  version = "0.3.10";
   format = "setuptools";
 
   disabled = pythonOlder "3.7";
···
     owner = "Bouni";
     repo = "python-luxtronik";
     rev = version;
-    sha256 = "mScdTQ82tV5fyy1S0YDDOz1UC4VB0OmSXD5gHp53WsE=";
+    sha256 = "sha256-JPY1HbNZanEsUpQ5W2kAwEFvwNGQI2hoogTZUGIg3YY=";
   };
 
   # Project has no tests

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

···
 
 buildPythonPackage rec {
   pname = "netdata";
-  version = "1.0.1";
+  version = "1.0.2";
   format = "pyproject";
 
   disabled = pythonOlder "3.8";
···
     owner = "home-assistant-ecosystem";
     repo = "python-netdata";
     rev = version;
-    sha256 = "sha256-4+cTIqytHrCPG7lUZv1IhL7Bk5GlTEveQTtuCkFIepo=";
+    sha256 = "sha256-D0W+zOpD2+iynhHMZh4obUSJJKmP3DnzA7blNWi6eHk=";
   };
 
   nativeBuildInputs = [

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

···
 }:
 
 buildPythonPackage rec {
-  version = "3.0.1";
+  version = "3.1.0";
   pname = "pamqp";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "0a9b49bde3f554ec49b47ebdb789133979985f24d5f4698935ed589a2d4392a4";
+    sha256 = "e4f0886d72c6166637a5513626148bf5a7e818073a558980e9aaed8b4ccf30da";
   };
 
   buildInputs = [ mock nose pep8 pylint mccabe ];

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

···
-{ lib, buildPythonPackage, fetchFromGitHub, isPy27, pythonOlder, fetchpatch
+{ lib
+, buildPythonPackage
 , cachecontrol
 , cachy
 , cleo
 , clikit
+, crashtest
+, dataclasses
+, entrypoints
+, fetchFromGitHub
+, fetchpatch
 , html5lib
 , httpretty
 , importlib-metadata
···
 , pexpect
 , pkginfo
 , poetry-core
+, pytest-mock
 , pytestCheckHook
-, pytest-cov
-, pytest-mock
+, pythonAtLeast
+, pythonOlder
 , requests
 , requests-toolbelt
 , shellingham
···
   pname = "poetry";
   version = "1.1.12";
   format = "pyproject";
-  disabled = isPy27;
+
+  disabled = pythonOlder "3.6";
 
   src = fetchFromGitHub {
     owner = "python-poetry";
···
      --replace 'version = "^21.2.0"' 'version = ">=21.2"'
   '';
 
-  nativeBuildInputs = [ intreehooks ];
+  nativeBuildInputs = [
+    intreehooks
+  ];
 
   propagatedBuildInputs = [
     cachecontrol
     cachy
     cleo
     clikit
+    crashtest
+    entrypoints
     html5lib
     keyring
     lockfile
···
     shellingham
     tomlkit
     virtualenv
-  ] ++ lib.optionals (pythonOlder "3.8") [ importlib-metadata ];
+  ] ++ lib.optionals (pythonOlder "3.7") [
+    dataclasses
+  ] ++ lib.optionals (pythonOlder "3.8") [
+    importlib-metadata
+  ];
 
   postInstall = ''
     mkdir -p "$out/share/bash-completion/completions"
···
     "$out/bin/poetry" completions fish > "$out/share/fish/vendor_completions.d/poetry.fish"
   '';
 
-  checkInputs = [ pytestCheckHook httpretty pytest-mock pytest-cov ];
-  preCheck = "export HOME=$TMPDIR";
+  checkInputs = [
+    pytestCheckHook
+    httpretty
+    pytest-mock
+  ];
+
+  preCheck = ''
+    export HOME=$TMPDIR
+  '';
+
   disabledTests = [
     # touches network
     "git"
···
     "lock"
     # fs permission errors
     "test_builder_should_execute_build_scripts"
+  ] ++ lib.optionals (pythonAtLeast "3.10") [
+    # RuntimeError: 'auto_spec' might be a typo; use unsafe=True if this is intended
+    "test_info_setup_complex_pep517_error"
   ];
 
   patches = [
     # The following patch addresses a minor incompatibility with
-    # pytest-mock.  This is addressed upstream in
+    # pytest-mock. This is addressed upstream in
     # https://github.com/python-poetry/poetry/pull/3457
     (fetchpatch {
       url = "https://github.com/python-poetry/poetry/commit/8ddceb7c52b3b1f35412479707fa790e5d60e691.diff";
···
     })
   ];
 
-  # allow for package to use pep420's native namespaces
-  pythonNamespaces = [ "poetry" ];
+  # Allow for package to use pep420's native namespaces
+  pythonNamespaces = [
+    "poetry"
+  ];
 
   meta = with lib; {
     homepage = "https://python-poetry.org/";

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

···
     pydantic
     typeguard
   ];
+  # We don't know why an early version of pydantic is required, see:
+  # https://github.com/openlawlibrary/pygls/issues/221
+  preBuild = ''
+    substituteInPlace setup.cfg \
+      --replace "pydantic>=1.7,<1.9" "pydantic"
+  '';
 
   checkInputs = [
     mock

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

···
 
 buildPythonPackage rec {
   pname = "pyhomematic";
-  version = "0.1.76";
+  version = "0.1.77";
 
   disabled = !isPy3k;
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "ea2496c920451ded4561e3758c8f77157fc00c40d1f75d8163e399fd3e0d795a";
+    sha256 = "00d95c21b95a17bc07586f69c976fb343a103adc0954d7b2d56c7160665625cb";
   };
 
   checkPhase = ''

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

···
 
 buildPythonPackage rec {
   pname = "pymelcloud";
-  version = "2.5.6";
+  version = "2.11.0";
   format = "setuptools";
 
   disabled = pythonOlder "3.8";
···
     owner = "vilppuvuorinen";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-QXOL3MftNibo1wUjz/KTQLNDk7pWL9VH/wd7LpEJOmE=";
+    sha256 = "1q6ny58cn9qy86blxbk6l2iklab7y11b734l7yb1bp35dmy27w26";
   };
 
   propagatedBuildInputs = [

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

···
 { lib
 , buildPythonPackage
 , fetchFromGitHub
+, fetchpatch
 , pythonOlder
 , flit
 , async-timeout
···
     pytestCheckHook
     pytest-asyncio
     pytest-httpx
+  ];
+
+  patches = [
+    # Can be removed with next release, https://github.com/cgtobi/PyRMVtransport/pull/55
+    (fetchpatch {
+      name = "update-tests.patch";
+      url = "https://github.com/cgtobi/PyRMVtransport/commit/fe93b3d9d625f9ccf8eb7b0c39e0ff41c72d2e77.patch";
+      sha256 = "sha256-t+GP5VG1S86vVSsisl85ZHBtOqxIi7QS83DA+HgRet4=";
+    })
   ];
 
   pythonImportsCheck = [

pkgs/development/python-modules/pytest-doctestplus/default.nix

···
 { lib
 , buildPythonPackage
+, fetchpatch
 , fetchPypi
-, pythonOlder
 , packaging
 , pytest
 , pytestCheckHook
+, pythonOlder
 , setuptools-scm
 }:
 
 buildPythonPackage rec {
   pname = "pytest-doctestplus";
   version = "0.11.2";
+  format = "setuptools";
+
   disabled = pythonOlder "3.7";
 
   src = fetchPypi {
···
     pytestCheckHook
   ];
 
+  patches = [
+    # Removal of distutils, https://github.com/astropy/pytest-doctestplus/pull/172
+    (fetchpatch {
+      name = "distutils-removal.patch";
+      url = "https://github.com/astropy/pytest-doctestplus/commit/ae2ee14cca0cde0fab355936995fa083529b00ff.patch";
+      sha256 = "sha256-uryKV7bWw2oz0glyh2lpGqtDPFvRTo8RmI1N1n15/d4=";
+    })
+  ];
+
   disabledTests = [
     # ERROR: usage: __main__.py [options] [file_or_dir] [file_or_dir] [...]
     # __main__.py: error: unrecognized arguments: --remote-data
···
     description = "Pytest plugin with advanced doctest features";
     homepage = "https://astropy.org";
     license = licenses.bsd3;
-    maintainers = [ maintainers.costrouc ];
+    maintainers = with maintainers; [ costrouc ];
   };
 }

pkgs/development/python-modules/pytest-httpx/default.nix

···
 , pytest
 , pytest-asyncio
 , pytestCheckHook
+, pythonOlder
 }:
 
 buildPythonPackage rec {
   pname = "pytest-httpx";
-  version = "0.15.0";
+  version = "0.17.3";
+  format = "setuptools";
+
+  disabled = pythonOlder "3.6";
 
   src = fetchFromGitHub {
     owner = "Colin-b";
     repo = "pytest_httpx";
     rev = "v${version}";
-    sha256 = "08dxvjkxlnam3r0yp17495d1vksyawzzkpykacjql1gi6hqlfrwg";
+    sha256 = "sha256-cJRzjNIN9Fc8vcjmndW+akjxDSp+wFahY2MEslgXIwM=";
   };
 
-  buildInputs = [ pytest ];
+  buildInputs = [
+    pytest
+  ];
 
   propagatedBuildInputs = [
     httpx
···
     pytestCheckHook
   ];
 
-  pythonImportsCheck = [ "pytest_httpx" ];
+  pythonImportsCheck = [
+    "pytest_httpx"
+  ];
 
   meta = with lib; {
     description = "Send responses to httpx";
     homepage = "https://github.com/Colin-b/pytest_httpx";
     license = licenses.mit;
-    maintainers = with maintainers; [ SuperSandro2000 ];
+    maintainers = with maintainers; [ fab SuperSandro2000 ];
   };
 }

pkgs/development/python-modules/scikit-survival/default.nix

···
 
 buildPythonPackage rec {
   pname = "scikit-survival";
-  version = "0.16.0";
+  version = "0.17.0";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "d3573eb1df9d516c75994a8a82108b6c7a5ca7ea8a9af60b38f3f65c3e227fa7";
+    sha256 = "ba49325f6a31e8bdccfb88337aa85218d209e88a6a704e9c41ef13bf749e0f46";
   };
 
   nativeBuildInputs = [

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

···
 
 buildPythonPackage rec {
   pname = "screenlogicpy";
-  version = "0.5.3";
+  version = "0.5.4";
   format = "setuptools";
 
   disabled = pythonOlder "3.6";
···
     owner = "dieselrabbit";
     repo = pname;
     rev = "v${version}";
-    sha256 = "1ic19l0xr2wlnc8q6nhvv747k0f4j9k94ix14zkrwpp9nl09sm8j";
+    sha256 = "0r9227s4v17jm5n0j31ssnak9f5p7xfvz4r1fwy61286is3j5gbb";
   };
 
   checkInputs = [

pkgs/development/python-modules/smart-meter-texas/default.nix

···
 
 buildPythonPackage rec {
   pname = "smart-meter-texas";
-  version = "0.4.7";
+  version = "0.5.0";
 
   disabled = pythonOlder "3.6";
 
···
     owner = "grahamwetzler";
     repo = "smart-meter-texas";
     rev = "v${version}";
-    sha256 = "1hfvv3kpkc7i9mn58bjgvwjj0mi2syr8fv4r8bwbhq5sailma27j";
+    sha256 = "1f5blmz3w549qjqn5xmdk1fx2pqd76hnlc9p439r7yc473nhw69w";
   };
 
   postPatch = ''

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

···
 { lib
+, stdenv
 , buildPythonPackage
 , fetchPypi
 , isPy27
···
 
 buildPythonPackage rec {
   pname = "sounddevice";
-  version = "0.4.3";
+  version = "0.4.4";
   disabled = isPy27;
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "f1667a7467b65fac4c4ebf668b4e9698eb7333fc3d32bc3c7ec9839ea7cb6c20";
+    sha256 = "sha256-9pD1qkGKViaMe9vJfWl8ha3QE0xcedRLiirXobhdp4k=";
   };
 
   propagatedBuildInputs = [ cffi numpy portaudio ];
···
   patches = [
     (substituteAll {
       src = ./fix-portaudio-library-path.patch;
-      portaudio = "${portaudio}/lib/libportaudio.so.2";
+      portaudio = "${portaudio}/lib/libportaudio${stdenv.hostPlatform.extensions.sharedLibrary}";
     })
   ];
 

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

···
 buildPythonPackage rec {
   pname = "spyse-python";
   version = "2.2.3";
+  format = "setuptools";
 
   disabled = pythonOlder "3.8";
 
···
   postPatch = ''
     substituteInPlace setup.py \
       --replace "'dataclasses~=0.6'," "" \
-      --replace "responses~=0.13.3" "responses>=0.13.3"
+      --replace "responses~=0.13.3" "responses>=0.13.3" \
+      --replace "limiter~=0.1.2" "limiter>=0.1.2"
   '';
 
   pythonImportsCheck = [

pkgs/development/python-modules/syslog-rfc5424-formatter/default.nix

···
+{ lib
+, buildPythonPackage
+, fetchFromGitHub
+}:
+
+buildPythonPackage rec {
+  pname = "syslog-rfc5424-formatter";
+  version = "1.2.2";
+
+  src = fetchFromGitHub {
+    owner = "easypost";
+    repo = pname;
+    rev = "v${version}";
+    sha256 = "17ym5ls5r6dd9pg9frdz8myfq5fxyqlwdq1gygc9vnrxbgw2c9kb";
+  };
+
+  # Tests are not picked up, review later again
+  doCheck = false;
+
+  pythonImportsCheck = [ "syslog_rfc5424_formatter" ];
+
+  meta = with lib; {
+    description = "Python logging formatter for emitting RFC5424 Syslog messages";
+    homepage = "https://github.com/easypost/syslog-rfc5424-formatter";
+    license = with licenses; [ isc ];
+    maintainers = with maintainers; [ fab ];
+  };
+}

pkgs/development/python-modules/types-requests/default.nix

···
 { lib
 , buildPythonPackage
 , fetchPypi
+, types-urllib3
 }:
 
 buildPythonPackage rec {
   pname = "types-requests";
-  version = "2.27.2";
+  version = "2.27.5";
   format = "setuptools";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "c902c5433ad103053011c6ac036317ac6f6a8e8a6926fc470a8d2ef791236da7";
+    sha256 = "sha256-pn3BqFEjErjLifO6lfmg5p7zQ2rnfJvU8yjNiPF63aI=";
   };
+
+  propagatedBuildInputs = [
+    types-urllib3
+  ];
 
   # Module doesn't have tests
   doCheck = false;

pkgs/development/python-modules/types-urllib3/default.nix

···
+{ lib
+, buildPythonPackage
+, fetchPypi
+}:
+
+buildPythonPackage rec {
+  pname = "types-urllib3";
+  version = "1.26.4";
+  format = "setuptools";
+
+  src = fetchPypi {
+    inherit pname version;
+    hash = "sha256-NcF74J4bzvOx4hAcUXK5fNt4MwkVlzx0H0wZedhAXvk=";
+  };
+
+  # Module doesn't have tests
+  doCheck = false;
+
+  pythonImportsCheck = [
+    "urllib3-stubs"
+  ];
+
+  meta = with lib; {
+    description = "Typing stubs for urllib3";
+    homepage = "https://github.com/python/typeshed";
+    license = licenses.asl20;
+    maintainers = with maintainers; [ fab ];
+  };
+}

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

···
-{ lib, buildPythonPackage, fetchFromGitHub, GitPython, pytestCheckHook, backoff, requests }:
+{ lib
+, backoff
+, buildPythonPackage
+, fetchFromGitHub
+, GitPython
+, pytestCheckHook
+, pythonOlder
+, requests
+}:
 
 buildPythonPackage rec {
   pname = "versionfinder";
   version = "1.1.1";
+  format = "setuptools";
+
+  disabled = pythonOlder "3.7";
 
   src = fetchFromGitHub {
     owner = "jantman";
···
   ];
 
   disabledTestPaths = [
-    # acceptance tests use the network
+    # Acceptance tests use the network
     "versionfinder/tests/test_acceptance.py"
   ];
 
-  pythonImportsCheck = [ "versionfinder" ];
+  disabledTests = [
+    # Tests are out-dated
+    "TestFindPipInfo"
+  ];
+
+  pythonImportsCheck = [
+    "versionfinder"
+  ];
 
   meta = with lib; {
     description = "Find the version of another package, whether installed via pip, setuptools or git";

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

···
 buildPythonPackage rec {
   pname = "zeep";
   version = "4.1.0";
+
   disabled = pythonOlder "3.6";
 
   src = fetchFromGitHub {
···
   disabledTests = [
     # lxml.etree.XMLSyntaxError: Extra content at the end of the document, line 2, column 64
     "test_mime_content_serialize_text_xml"
+    # Tests are outdated
+    "test_load"
+    "test_load_cache"
+    "test_post"
   ];
 
-  pythonImportsCheck = [ "zeep" ];
+  pythonImportsCheck = [
+    "zeep"
+  ];
 
   meta = with lib; {
     description = "Python SOAP client";

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

···
 
 buildPythonPackage rec {
   pname = "zstd";
-  version = "1.5.0.4";
+  version = "1.5.1.0";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "0d048f03fc6354c565ac1e36bb6bf697cfe9941217717fc6a2076529d8b860c3";
+    sha256 = "9519bb0cd91c4498cd8cf66ef88fb22e5d6a442317704e6afd00b12726d17d0a";
   };
 
   postPatch = ''

pkgs/development/tools/build-managers/jam/default.nix

···
   '';
 
   buildPhase = ''
+    runHook preBuild
+
     make jam0
-    ./jam0 -j$NIX_BUILD_CORES -sBINDIR=$out/bin install
+
+    runHook postBuild
   '';
 
   installPhase = ''
+    runHook preInstall
+
+    ./jam0 -j$NIX_BUILD_CORES -sBINDIR=$out/bin install
     mkdir -p $out/doc/jam
     cp *.html $out/doc/jam
+
+    runHook postInstall
   '';
 
   enableParallelBuilding = true;

pkgs/development/tools/build-managers/jam/ftjam.nix

···
+{ lib
+, stdenv
+, fetchurl
+, bison
+}:
+
+stdenv.mkDerivation rec {
+  pname = "ftjam";
+  version = "2.5.2";
+
+  src = fetchurl {
+    url = "https://downloads.sourceforge.net/project/freetype/${pname}/${version}/${pname}-${version}.tar.bz2";
+    hash = "sha256-6JdzUAqSkS3pGOn+v/q+S2vOedaa8ZRDX04DK4ptZqM=";
+  };
+
+  nativeBuildInputs = [
+    bison
+  ];
+
+  preConfigure = ''
+    unset AR
+  '';
+
+  buildPhase = ''
+    runHook preBuild
+
+    make jam0
+
+    runHook postBuild
+  '';
+
+  installPhase = ''
+    runHook preInstall
+
+    ./jam0 -j$NIX_BUILD_CORES -sBINDIR=$out/bin install
+    mkdir -p $out/doc/jam
+    cp *.html $out/doc/jam
+
+    runHook postInstall
+  '';
+
+  enableParallelBuilding = true;
+
+  meta = with lib; {
+    homepage = "https://freetype.org/jam/";
+    description = "Freetype's enhanced, backwards-compatible Jam clone";
+    license = licenses.free;
+    maintainers = with maintainers; [ AndersonTorres ];
+    platforms = platforms.unix;
+  };
+}
+# TODO: setup hook for Jam

pkgs/development/tools/gofumpt/default.nix

···
 
 buildGoModule rec {
   pname = "gofumpt";
-  version = "0.2.0";
+  version = "0.2.1";
 
   src = fetchFromGitHub {
     owner = "mvdan";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-Kgj3f90bAtaVl4mby6FQr4t4BT4I3QLtHhvO10f1BOk=";
+    sha256 = "sha256-NkflJwFdVcFTjXkDr8qqAFUlKwGNPTso6hvu7Vikn2U=";
   };
 
-  vendorSha256 = "sha256-gxxK2eUmYUqHjt8HP6OANaHsO43wCaodUDR4BlMY8Zw=";
+  vendorSha256 = "sha256-RZPfdj+rimKGvRZKaXOirkd7ietri55rBofwa/l2z8s=";
 
   doCheck = false;
 

pkgs/development/tools/jo/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "jo";
-  version = "1.4";
+  version = "1.6";
 
   src = fetchFromGitHub {
     owner  = "jpmens";
     repo = "jo";
     rev = version;
-    sha256 ="1jnv3g38vaa66m83hqibyki31ii81xfpvjw6wgdv18ci3iwvsz3v";
+    sha256 ="sha256-aATCeJV0x+XHOQbwulutxivPzGVQ0mJj90vA+6IM124=";
   };
 
   enableParallelBuilding = true;

pkgs/development/tools/misc/clojure-lsp/default.nix

···
 
 buildGraalvmNativeImage rec {
   pname = "clojure-lsp";
-  version = "2021.11.02-15.24.47";
+  version = "2022.01.03-19.46.10";
 
   src = fetchFromGitHub {
     owner = pname;
     repo = pname;
     rev = version;
-    sha256 = "sha256-PBbo8yx4g4SsViUA1jnwqF8q9Dfn3lrgK2CP026Bm4Q=";
+    sha256 = "sha256-BbhT4I4M7PwHHFwNDNY4mJxsreJVOEwlValZTgS0Zs8=";
   };
 
   jar = fetchurl {
     url = "https://github.com/clojure-lsp/clojure-lsp/releases/download/${version}/clojure-lsp.jar";
-    sha256 = "sha256-k0mzibcLAspklCPE6f2qsUm9bwSvcJRgWecMBq7mpF0=";
+    sha256 = "sha256-QG9Z4wkzh1kaX44oee325BvY2XqXRo4iBjY5LPnkLBQ=";
   };
 
   # https://github.com/clojure-lsp/clojure-lsp/blob/2021.11.02-15.24.47/graalvm/native-unix-compile.sh#L18-L27
···
 
     export HOME="$(mktemp -d)"
     ./${pname} --version | fgrep -q '${version}'
-    ${babashka}/bin/bb integration-test ./${pname}
-
+  ''
+    # TODO: fix classpath issue per https://github.com/NixOS/nixpkgs/pull/153770
+    #${babashka}/bin/bb integration-test ./${pname}
+  + ''
     runHook postCheck
   '';
 

pkgs/development/tools/misc/strace/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "strace";
-  version = "5.15";
+  version = "5.16";
 
   src = fetchurl {
     url = "https://strace.io/files/${version}/${pname}-${version}.tar.xz";
-    sha256 = "sha256-68rCLylzNSlNxlRCXLw84BM0O+zm2iaZ467Iau6Nctw=";
+    sha256 = "sha256-3H2yMP8+V8JJgwupSsqyuGLaH8qsVUF+m4UEGoM8ooU=";
   };
 
   depsBuildBuild = [ buildPackages.stdenv.cc ];

pkgs/games/blockattack/default.nix

···
+{ lib
+, stdenv
+, fetchFromGitHub
+, SDL2
+, SDL2_image
+, SDL2_mixer
+, SDL2_ttf
+, boost
+, cmake
+, gettext
+, physfs
+, pkg-config
+, zip
+}:
+
+stdenv.mkDerivation rec {
+  pname = "blockattack";
+  version = "2.7.0";
+
+  src = fetchFromGitHub {
+    name = "${pname}-${version}-src";
+    owner = "blockattack";
+    repo = "blockattack-game";
+    rev = "v${version}";
+    hash = "sha256-ySLm3AdoJRiMRdla45OJh8ZIFYNh+HzjG2VnFqoWuZA=";
+  };
+
+  nativeBuildInputs = [
+    cmake
+    pkg-config
+    gettext
+    zip
+  ];
+
+  buildInputs = [
+    SDL2
+    SDL2_image
+    SDL2_mixer
+    SDL2_ttf
+    SDL2_ttf
+    boost
+    physfs
+  ];
+
+  preConfigure = ''
+    patchShebangs packdata.sh source/misc/translation/*.sh
+    chmod +x ./packdata.sh
+    ./packdata.sh
+  '';
+
+  meta = with lib; {
+    homepage = "https://blockattack.net/";
+    description = "An open source clone of Panel de Pon (aka Tetris Attack)";
+    license = licenses.gpl2Plus;
+    maintainers = with maintainers; [ AndersonTorres ];
+    platforms = platforms.unix;
+    broken = stdenv.isDarwin;
+  };
+}

pkgs/games/the-legend-of-edgar/default.nix

···
+{ lib
+, stdenv
+, fetchFromGitHub
+, SDL2
+, SDL2_image
+, SDL2_mixer
+, SDL2_ttf
+, gettext
+, libpng
+, pkg-config
+, zlib
+}:
+
+stdenv.mkDerivation rec {
+  pname = "the-legend-of-edgar";
+  version = "1.35";
+
+  src = fetchFromGitHub {
+    name = "${pname}-${version}-src";
+    owner = "riksweeney";
+    repo = "edgar";
+    rev = version;
+    hash = "sha256-ojy4nEW9KiSte/AoFUMPrKCxvIeQpMVIL4ileHiBydo=";
+  };
+
+  nativeBuildInputs = [
+    pkg-config
+    gettext
+  ];
+
+  buildInputs = [
+    SDL2
+    SDL2_image
+    SDL2_mixer
+    SDL2_ttf
+    libpng
+    zlib
+  ];
+
+  dontConfigure = true;
+
+  makefile = "makefile";
+
+  makeFlags = [
+    "PREFIX=${placeholder "out"}"
+    "BIN_DIR=${placeholder "out"}/bin/"
+  ];
+
+  # TODO: remove the setting below when the next version arrives
+  # https://github.com/riksweeney/edgar/pull/57
+  preBuild = ''
+    export CFLAGS=$(sdl2-config --cflags)
+  '';
+
+  meta = with lib; {
+    homepage = "https://www.parallelrealities.co.uk/games/edgar";
+    description = "A 2D platform game with a persistent world";
+    longDescription = ''
+      When Edgar's father fails to return home after venturing out one dark and
+      stormy night, Edgar fears the worst: he has been captured by the evil
+      sorcerer who lives in a fortress beyond the forbidden swamp.
+
+      Donning his armour, Edgar sets off to rescue him, but his quest will not
+      be easy...
+
+      The Legend of Edgar is a platform game, not unlike those found on the
+      Amiga and SNES. Edgar must battle his way across the world, solving
+      puzzles and defeating powerful enemies to achieve his quest.
+    '';
+    license = licenses.gpl1Plus;
+    maintainers = with maintainers; [ AndersonTorres ];
+    platforms = platforms.unix;
+    broken = stdenv.isDarwin;
+  };
+}

pkgs/misc/emulators/wine/sources.nix

···
 
   unstable = fetchurl rec {
     # NOTE: Don't forget to change the SHA256 for staging as well.
-    version = "7.0-rc2";
+    version = "7.0-rc5";
     url = "https://dl.winehq.org/wine/source/7.0/wine-${version}.tar.xz";
-    sha256 = "sha256-D92OOa9fFdBd0wZbtRLz9oOhhJ3AtHcSZP0EaWyW7X0=";
+    sha256 = "sha256-jQjHneYAZ3H26EXje9cyoduXN7TakiLksDdzNoi3d1g=";
     inherit (stable) gecko32 gecko64;
 
     ## see http://wiki.winehq.org/Mono
···
   staging = fetchFromGitHub rec {
     # https://github.com/wine-staging/wine-staging/releases
     inherit (unstable) version;
-    sha256 = "sha256-UkwvKKRXyFjLfYbL8Ienpp5pxUzMQY1bEyAkoP7Xdz4=";
+    sha256 = "sha256-RFwDI8eGw9BikQ8X+S1+EPHKAgNaYHuZOJzmlg12ROI=";
     owner = "wine-staging";
     repo = "wine-staging";
     rev = "v${version}";

pkgs/misc/vscode-extensions/default.nix

···
         };
       };
 
+      antyos.openscad = buildVscodeMarketplaceExtension {
+        mktplcRef = {
+          name = "openscad";
+          publisher = "Antyos";
+          version = "1.1.1";
+          sha256 = "1adcw9jj3npk3l6lnlfgji2l529c4s5xp9jl748r9naiy3w3dpjv";
+        };
+        meta = with lib; {
+          changelog = "https://marketplace.visualstudio.com/items/Antyos.openscad/changelog";
+          description = "OpenSCAD highlighting, snippets, and more for VSCode";
+          homepage = "https://github.com/Antyos/vscode-openscad";
+          license = licenses.gpl3;
+        };
+      };
+
       apollographql.vscode-apollo = buildVscodeMarketplaceExtension {
         mktplcRef = {
           name = "vscode-apollo";

pkgs/os-specific/linux/android-udev-rules/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "android-udev-rules";
-  version = "20210501";
+  version = "20220102";
 
   src = fetchFromGitHub {
     owner = "M0Rf30";
     repo = "android-udev-rules";
     rev = version;
-    sha256 = "sha256-rlTulWclPqMl9LdHdcAtLARXGItiSeF3RX+neZrjgV4=";
+    sha256 = "sha256-D2dPFvuFcZtosfTfsW0lmK5y8zqHdIxJBlvmP/R91CE=";
   };
 
   installPhase = ''

pkgs/servers/mail/opensmtpd/extras.nix

···
-{ lib, stdenv, fetchurl, openssl, libevent, libasr,
-  python2, pkg-config, lua5, perl, libmysqlclient, postgresql, sqlite, hiredis,
-  enablePython ? true,
+{ lib, stdenv, fetchurl, openssl, libevent, libasr, ncurses,
+  pkg-config, lua5, perl, libmysqlclient, postgresql, sqlite, hiredis,
   enableLua ? true,
   enablePerl ? true,
   enableMysql ? true,
···
 
   nativeBuildInputs = [ pkg-config ];
   buildInputs = [ openssl libevent
-    libasr python2 lua5 perl libmysqlclient postgresql sqlite hiredis ];
+    libasr lua5 perl libmysqlclient postgresql sqlite hiredis ];
 
   configureFlags = [
     "--sysconfdir=/etc"
···
     "--with-table-stub"
     "--with-scheduler-ram"
     "--with-scheduler-stub"
-
-  ] ++ lib.optionals enablePython [
-    "--with-python=${python2}"
-    "--with-filter-python"
-    "--with-queue-python"
-    "--with-table-python"
-    "--with-scheduler-python"
 
   ] ++ lib.optionals enableLua [
     "--with-lua=${pkg-config}"

pkgs/servers/teleport/default.nix

···
 , protobuf
 , stdenv
 , xdg-utils
+, nixosTests
 
 , withRoleTester ? true
 }:
···
     $out/bin/tctl version | grep ${version} > /dev/null
     $out/bin/teleport version | grep ${version} > /dev/null
   '';
+
+  passthru.tests = nixosTests.teleport;
 
   meta = with lib; {
     description = "Certificate authority and access plane for SSH, Kubernetes, web applications, and databases";

pkgs/servers/web-apps/baget/default.nix

···
+{ buildDotnetModule, lib, fetchFromGitHub, dotnetCorePackages }:
+
+buildDotnetModule rec {
+  pname = "BaGet";
+  version = "0.4.0-preview2";
+
+  src = fetchFromGitHub {
+    owner = "loic-sharma";
+    repo = pname;
+    rev = "v${version}";
+    sha256 = "S/3CjXB/fBDzxLuQBQB3CKgEkmzUA8ZzzvzXLN8hfBU=";
+  };
+
+  projectFile = "src/BaGet/BaGet.csproj";
+  nugetDeps = ./deps.nix;
+
+  dotnet-sdk = dotnetCorePackages.sdk_3_1;
+  dotnet-runtime = dotnetCorePackages.aspnetcore_3_1;
+
+  passthru.updateScript = ./updater.sh;
+
+  meta = with lib; {
+    description = "A lightweight NuGet and symbol server";
+    license = licenses.mit;
+    homepage = "https://loic-sharma.github.io/BaGet/";
+    platforms = platforms.all;
+    maintainers = [ maintainers.abbradar ];
+  };
+}

pkgs/servers/web-apps/baget/deps.nix

···
+{ fetchNuGet }: [
+  (fetchNuGet { pname = "Aliyun.OSS.SDK.NetCore"; version = "2.9.1"; sha256 = "0j07j6cr0lqmmdwgz5alxlq5ifa5vzb58r1rqkgvf49nirz6jhfs"; })
+  (fetchNuGet { pname = "AWSSDK.Core"; version = "3.3.104.22"; sha256 = "1930axxsbiahv0rrav34zj355fwxx4nzbvd93sp5g94z6pdh0438"; })
+  (fetchNuGet { pname = "AWSSDK.S3"; version = "3.3.110.20"; sha256 = "0i8vcyxmszhsdm73fvg17yx6hfslml3y1sw0cd1lzv10avqfb7v9"; })
+  (fetchNuGet { pname = "AWSSDK.SecurityToken"; version = "3.3.104.27"; sha256 = "13ywh3d8fc8ndyg40yh386fw54s1w4sw9qqbjvmh40nb20s4wwrv"; })
+  (fetchNuGet { pname = "Google.Api.Gax"; version = "2.5.0"; sha256 = "0q6pi53px998i3gdndla8v0zqdpyi9gnsy9mdcfpkrg09vfbdsl9"; })
+  (fetchNuGet { pname = "Google.Api.Gax.Rest"; version = "2.5.0"; sha256 = "1zkjl5zh6qwdz4qmnxnk5877pas638i2qi25znilhqqf3mrkp0rp"; })
+  (fetchNuGet { pname = "Google.Apis"; version = "1.35.1"; sha256 = "1022l8m7v9f3rkjc9l11mkzwsbmqx9sk5f4aym035vn9hdr16d49"; })
+  (fetchNuGet { pname = "Google.Apis.Auth"; version = "1.35.1"; sha256 = "1qdnd1nq9bfgyljmiww91pfi0iz1n29rz2dlizhxcijqya2ldha3"; })
+  (fetchNuGet { pname = "Google.Apis.Core"; version = "1.35.1"; sha256 = "01dfw2kxknlc5pm7x1q88lv9j979509lkkgvlffjry5bawsxsja4"; })
+  (fetchNuGet { pname = "Google.Apis.Storage.v1"; version = "1.35.1.1266"; sha256 = "16wmqv0nqw8s0cmv2zmjd8raz2swygqn9jqg18ja1bfaz88r5c3l"; })
+  (fetchNuGet { pname = "Google.Cloud.Storage.V1"; version = "2.2.1"; sha256 = "0jpzca4xs82p3yyni8c1chq2pzzvmpf3j25ch0wj1w2ha36r9acj"; })
+  (fetchNuGet { pname = "Humanizer"; version = "2.11.10"; sha256 = "057pqzvdxsbpnnc5f1xkqg7j3ywp68ggia3w74fgqp0158dm6rdk"; })
+  (fetchNuGet { pname = "Humanizer.Core"; version = "2.11.10"; sha256 = "0z7kmd5rh1sb6izq0vssk6c2p63n00xglk45s7ga9z18z9aaskxv"; })
+  (fetchNuGet { pname = "Humanizer.Core.af"; version = "2.11.10"; sha256 = "18fiixfvjwn8m1i8z2cz4aqykzylvfdqmmpwc2zcd8sr1a2xm86z"; })
+  (fetchNuGet { pname = "Humanizer.Core.ar"; version = "2.11.10"; sha256 = "009fpm4jd325izm82ipipsvlwd31824gvskda68bdwi4yqmycz4p"; })
+  (fetchNuGet { pname = "Humanizer.Core.az"; version = "2.11.10"; sha256 = "144b9diwprabxwgi5a98k5iy95ajq4p7356phdqi2lhzwbz7b6a9"; })
+  (fetchNuGet { pname = "Humanizer.Core.bg"; version = "2.11.10"; sha256 = "1b9y40gvq2kwnj5wa40f8cbywv79jkajcwknagrgr27sykpfadl2"; })
+  (fetchNuGet { pname = "Humanizer.Core.bn-BD"; version = "2.11.10"; sha256 = "18pn4jcp36ygcx283l3fi9bs5d7q1a384b72a10g5kl0qckn88ay"; })
+  (fetchNuGet { pname = "Humanizer.Core.cs"; version = "2.11.10"; sha256 = "03crw1lnzp32v2kcdmllkrsqh07r4ggw9gyc96qw7cv0nk5ch1h8"; })
+  (fetchNuGet { pname = "Humanizer.Core.da"; version = "2.11.10"; sha256 = "0glby12zra3y3yiq4cwq1m6wjcjl8f21v8ghi6s20r48glm8vzy9"; })
+  (fetchNuGet { pname = "Humanizer.Core.de"; version = "2.11.10"; sha256 = "0a35xrm1f9p74x0fkr52bw9sd54vdy9d5rnvf565yh8ww43xfk7b"; })
+  (fetchNuGet { pname = "Humanizer.Core.el"; version = "2.11.10"; sha256 = "0bhwwdx5vc48zikdsbrkghdhwahxxc2lkff0yaa5nxhbhasl84h8"; })
+  (fetchNuGet { pname = "Humanizer.Core.es"; version = "2.11.10"; sha256 = "07bw07qy8nyzlgxl7l2lxv9f78qmkfppgzx7iyq5ikrcnpvc7i9q"; })
+  (fetchNuGet { pname = "Humanizer.Core.fa"; version = "2.11.10"; sha256 = "00d4hc1pfmhfkc5wmx9p7i00lgi4r0k6wfcns9kl1syjxv3bs5f2"; })
+  (fetchNuGet { pname = "Humanizer.Core.fi-FI"; version = "2.11.10"; sha256 = "0z4is7pl5jpi4pfdvd2zvx5mp00bj26d9l9ksqyc0liax8nfzyik"; })
+  (fetchNuGet { pname = "Humanizer.Core.fr"; version = "2.11.10"; sha256 = "0sybpg6kbbhrnk7gxcdk7ppan89lsfqsdssrg4i1dm8w48wgicap"; })
+  (fetchNuGet { pname = "Humanizer.Core.fr-BE"; version = "2.11.10"; sha256 = "1s25c86nl9wpsn6fydzwv4rfmdx5sm0vgyd7xhw5344k20gazvhv"; })
+  (fetchNuGet { pname = "Humanizer.Core.he"; version = "2.11.10"; sha256 = "1nx61qkjd6p9r36dmnm4942khyv35fpdqmb2w69gz6463g4d7z29"; })
+  (fetchNuGet { pname = "Humanizer.Core.hr"; version = "2.11.10"; sha256 = "02jhcyj72prkqsjxyilv04drm0bknqjh2r893jlbsfi9vjg2zay3"; })
+  (fetchNuGet { pname = "Humanizer.Core.hu"; version = "2.11.10"; sha256 = "0yb6ly4s1wdyaf96h2dvifqyb575aid6irwl3qx8gcvrs0xpcxdp"; })
+  (fetchNuGet { pname = "Humanizer.Core.hy"; version = "2.11.10"; sha256 = "0b7vaqldn7ca3xi4gkvkhjk900kw2zwb0m0d20bg45a83zdlx79c"; })
+  (fetchNuGet { pname = "Humanizer.Core.id"; version = "2.11.10"; sha256 = "1yqxirknwga4j18k7ixwgqxlv20479afanhariy3c5mkwvglsr9b"; })
+  (fetchNuGet { pname = "Humanizer.Core.it"; version = "2.11.10"; sha256 = "1skwgj5a6kkx3pm9w4f29psch69h1knmwbkdydlmx13h452p1w4l"; })
+  (fetchNuGet { pname = "Humanizer.Core.ja"; version = "2.11.10"; sha256 = "1wpc3yz9v611dqbw8j5yimk8dpz0rvpnls4rmlnp1m47gavpj8x4"; })
+  (fetchNuGet { pname = "Humanizer.Core.ko-KR"; version = "2.11.10"; sha256 = "1df0kd7vwdc3inxfkb3wsl1aw3d6vbab99dzh08p4m04g7i2c1a9"; })
+  (fetchNuGet { pname = "Humanizer.Core.ku"; version = "2.11.10"; sha256 = "17b66xfgwjr0sffx0hw4c6l90h43z7ffylrs26hgav0n110q2nwg"; })
+  (fetchNuGet { pname = "Humanizer.Core.lv"; version = "2.11.10"; sha256 = "0czxx4b9g0w7agykdl82wds09zasa9y58dmgjm925amlfz4wkyzs"; })
+  (fetchNuGet { pname = "Humanizer.Core.ms-MY"; version = "2.11.10"; sha256 = "0kix95nbw94fx0dziyz80y59i7ii7d21b63f7f94niarljjq36i3"; })
+  (fetchNuGet { pname = "Humanizer.Core.mt"; version = "2.11.10"; sha256 = "1rwy6m22pq65gxn86xlr9lv818fp5kb0wz98zxxfljc2iviw1f4p"; })
+  (fetchNuGet { pname = "Humanizer.Core.nb"; version = "2.11.10"; sha256 = "0ra2cl0avvv4sylha7z76jxnb4pdiqfbpr5m477snr04dsjxd9q9"; })
+  (fetchNuGet { pname = "Humanizer.Core.nb-NO"; version = "2.11.10"; sha256 = "1qszib03pvmjkrg8za7jjd2vzrs9p4fn2rmy82abnzldkhvifipq"; })
+  (fetchNuGet { pname = "Humanizer.Core.nl"; version = "2.11.10"; sha256 = "1i9bvy0i2yyasl9mgxiiwrkmfpm2c53d3wwdp9270r6120sxyy63"; })
+  (fetchNuGet { pname = "Humanizer.Core.pl"; version = "2.11.10"; sha256 = "0kggh4wgcic7wzgxy548n6w61schss2ccf9kz8alqshfi42xifby"; })
+  (fetchNuGet { pname = "Humanizer.Core.pt"; version = "2.11.10"; sha256 = "09j90s8x1lpvhfiy3syfnj8slkgcacf3xjy3pnkgxa6g4mi4f4bd"; })
+  (fetchNuGet { pname = "Humanizer.Core.ro"; version = "2.11.10"; sha256 = "1jgidmqfly91v1k22gn687mfql5bz7gjzp1aapi93vq5x635qssy"; })
+  (fetchNuGet { pname = "Humanizer.Core.ru"; version = "2.11.10"; sha256 = "13mmlh0ibxfyc85xrz3vx4mcg56mkzqql184iwdryq94p0g5ahil"; })
+  (fetchNuGet { pname = "Humanizer.Core.sk"; version = "2.11.10"; sha256 = "04ja06y5jaz1jwkwn117wx9cib04gpbi0vysn58a8sd5jrxmxai5"; })
+  (fetchNuGet { pname = "Humanizer.Core.sl"; version = "2.11.10"; sha256 = "05hxk9v3a7fn7s4g9jp5zxk2z6a33b9fkavyb1hjqnl2i37q2wja"; })
+  (fetchNuGet { pname = "Humanizer.Core.sr"; version = "2.11.10"; sha256 = "0x6l2msimrx72iywa1g0rqklgy209sdwg0r77i2lz0s1rvk5klm5"; })
+  (fetchNuGet { pname = "Humanizer.Core.sr-Latn"; version = "2.11.10"; sha256 = "01hdyn7mmbyy7f3aglawgnsj3nblcdpqjgzdcvniy73l536mira0"; })
+  (fetchNuGet { pname = "Humanizer.Core.sv"; version = "2.11.10"; sha256 = "0cbgchivw3d5ndib1zmgzmnymhyvfh9g9f0hijc860g5vaa9fkvh"; })
+  (fetchNuGet { pname = "Humanizer.Core.th-TH"; version = "2.11.10"; sha256 = "1v7f9x3b04iwhz9lb3ir8az8128nvcw1gi4park5zh3fg0f3mni0"; })
+  (fetchNuGet { pname = "Humanizer.Core.tr"; version = "2.11.10"; sha256 = "02c4ky0dskxkdrkc7vy8yzmvwjr1wqll1kzx0k21afhlx8xynjd4"; })
+  (fetchNuGet { pname = "Humanizer.Core.uk"; version = "2.11.10"; sha256 = "0900ilhwj8yvhyzpg1pjr7f5vrl62wp8dsnhk4c2igs20qvnv079"; })
+  (fetchNuGet { pname = "Humanizer.Core.uz-Cyrl-UZ"; version = "2.11.10"; sha256 = "09b7p2m8y49j49ckrmx2difgyj6y7fm2mwca093j8psxclsykcyr"; })
+  (fetchNuGet { pname = "Humanizer.Core.uz-Latn-UZ"; version = "2.11.10"; sha256 = "029kvkawqhlln52vpjpvr52dhr18ylk01cgsj2z8lxnqaka0q9hk"; })
+  (fetchNuGet { pname = "Humanizer.Core.vi"; version = "2.11.10"; sha256 = "0q4d47plsj956ivn82qwyidfxppjr9dp13m8c66aamrvhy4q8ny5"; })
+  (fetchNuGet { pname = "Humanizer.Core.zh-CN"; version = "2.11.10"; sha256 = "01dy5kf6ai8id77px92ji4kcxjc8haj39ivv55xy1afcg3qiy7mh"; })
+  (fetchNuGet { pname = "Humanizer.Core.zh-Hans"; version = "2.11.10"; sha256 = "16gcxgw2g6gck3nc2hxzlkbsg7wkfaqsjl87kasibxxh47zdqqv2"; })
+  (fetchNuGet { pname = "Humanizer.Core.zh-Hant"; version = "2.11.10"; sha256 = "1rjg2xvkwjjw3c7z9mdjjvbnl9lcvvhh4fr7l61rla2ynzdk46cj"; })
+  (fetchNuGet { pname = "Markdig"; version = "0.26.0"; sha256 = "1pg0yica8h1c2kx10pqzc5iclmlfll5wbw1bxa8l251w1qnfglv2"; })
+  (fetchNuGet { pname = "McMaster.Extensions.CommandLineUtils"; version = "2.5.0"; sha256 = "010vqyg5mb3cjzxznawxz7wvidj1yv664xgz93vf1zrww5vz6aal"; })
+  (fetchNuGet { pname = "Microsoft.AspNetCore.Mvc.Razor.Extensions"; version = "3.1.18"; sha256 = "0s168gac3g8666pllnmjdbq1v981qgc1wqypyl6pp92jvzvkndp6"; })
+  (fetchNuGet { pname = "Microsoft.AspNetCore.Mvc.Razor.RuntimeCompilation"; version = "3.1.18"; sha256 = "0069qv17rapqhp2hjzzqim5zxb6clmr9bj4vmfd2pm4byp215flj"; })
+  (fetchNuGet { pname = "Microsoft.AspNetCore.Razor.Language"; version = "3.1.18"; sha256 = "0rm6a5hsj4d2a1nlzfb34bm5z7wr826zg25xfbg51a3zvbgva9m7"; })
+  (fetchNuGet { pname = "Microsoft.Azure.Cosmos.Table"; version = "1.0.0"; sha256 = "0ms3nkifj3j7i1h6bxw49fha2iamxdxkzi51q37n0czcszx36apg"; })
+  (fetchNuGet { pname = "Microsoft.Azure.DocumentDB.Core"; version = "2.1.3"; sha256 = "017jq5a5ba4wmrrfr7daa07asnjl8xgvncgxlcyy83mln0xm67a5"; })
+  (fetchNuGet { pname = "Microsoft.Azure.KeyVault.Core"; version = "2.0.4"; sha256 = "0rv7z989zxk5myqd4n2a9ccxx9jr4jb3fslc6b4w3p0570af60hn"; })
+  (fetchNuGet { pname = "Microsoft.Azure.Search"; version = "5.0.1"; sha256 = "1xpwgcwahflrq5qa2acn0y5x1660qlh5iy0xmn6bisf9pbs6g7hr"; })
+  (fetchNuGet { pname = "Microsoft.Azure.Search.Common"; version = "5.0.1"; sha256 = "1ybbvm3iyi7r6v6j19jb16lqlq3am51wg68mzk3jdflk5czn28p7"; })
+  (fetchNuGet { pname = "Microsoft.Azure.Search.Data"; version = "5.0.1"; sha256 = "05skk65y8miwjzwvrr5br94byqipygi3mccl9x5wzbxqdhma7chq"; })
+  (fetchNuGet { pname = "Microsoft.Azure.Search.Service"; version = "5.0.1"; sha256 = "00767bbdi1zxb3vvw8k4666iv7wfb3fyxcligrin04qn9spjd2h7"; })
+  (fetchNuGet { pname = "Microsoft.Azure.Storage.Blob"; version = "9.4.1"; sha256 = "11273cf1a6rir6z016sa8r8jmrxc66zyhicciyyzanph6jwdfbf6"; })
+  (fetchNuGet { pname = "Microsoft.Azure.Storage.Common"; version = "9.4.1"; sha256 = "0kwrsfw0g8bciy53qrmgff8b8ik8wgn92szx0hdnvaqnv5dphsij"; })
+  (fetchNuGet { pname = "Microsoft.Bcl.AsyncInterfaces"; version = "1.0.0"; sha256 = "00dx5armvkqjxvkldz3invdlck9nj7w21dlsr2aqp1rqbyrbsbbh"; })
+  (fetchNuGet { pname = "Microsoft.Bcl.AsyncInterfaces"; version = "1.1.0"; sha256 = "1dq5yw7cy6s42193yl4iqscfw5vzkjkgv0zyy32scr4jza6ni1a1"; })
+  (fetchNuGet { pname = "Microsoft.Bcl.AsyncInterfaces"; version = "1.1.1"; sha256 = "0a1ahssqds2ympr7s4xcxv5y8jgxs7ahd6ah6fbgglj4rki1f1vw"; })
+  (fetchNuGet { pname = "Microsoft.Bcl.HashCode"; version = "1.1.0"; sha256 = "1ggsadahlp76zcn1plapszd5v5ja8rh479fwrahqd3knql4dfnr0"; })
+  (fetchNuGet { pname = "Microsoft.Bcl.HashCode"; version = "1.1.1"; sha256 = "0xwfph92p92d8hgrdiaka4cazqsjpg4ywfxfx6qbk3939f29kzl0"; })
+  (fetchNuGet { pname = "Microsoft.Build.Tasks.Git"; version = "1.0.0"; sha256 = "0avwja8vk56f2kr2pmrqx3h60bnwbs7ds062lhvhcxv87m5yfqnj"; })
+  (fetchNuGet { pname = "Microsoft.CodeAnalysis.Analyzers"; version = "2.9.3"; sha256 = "1kskwc9gyd2sx3zwx52qwfsl7s0xhaclmlnxvjsb4jgvpydv3xii"; })
+  (fetchNuGet { pname = "Microsoft.CodeAnalysis.Common"; version = "3.3.0"; sha256 = "1vwhsp3pjgcfnpapkps9a3z9n2ryiv5bbhzycfljngj5grj63rg2"; })
+  (fetchNuGet { pname = "Microsoft.CodeAnalysis.CSharp"; version = "3.3.0"; sha256 = "09nmd5h1r2q0dwp1dfpn4anvs8sfi3rwcgpcv28lrhky8vc51424"; })
+  (fetchNuGet { pname = "Microsoft.CodeAnalysis.Razor"; version = "3.1.18"; sha256 = "1fa10n15mifbwq2yilpkmag6apaix1nxb643306a4cmcjvr9nvp1"; })
+  (fetchNuGet { pname = "Microsoft.CSharp"; version = "4.0.1"; sha256 = "0zxc0apx1gcx361jlq8smc9pfdgmyjh6hpka8dypc9w23nlsh6yj"; })
+  (fetchNuGet { pname = "Microsoft.CSharp"; version = "4.3.0"; sha256 = "0gw297dgkh0al1zxvgvncqs0j15lsna9l1wpqas4rflmys440xvb"; })
+  (fetchNuGet { pname = "Microsoft.CSharp"; version = "4.5.0"; sha256 = "01i28nvzccxbqmiz217fxs6hnjwmd5fafs37rd49a6qp53y6623l"; })
+  (fetchNuGet { pname = "Microsoft.CSharp"; version = "4.7.0"; sha256 = "0gd67zlw554j098kabg887b5a6pq9kzavpa3jjy5w53ccjzjfy8j"; })
+  (fetchNuGet { pname = "Microsoft.Data.SqlClient"; version = "1.1.3"; sha256 = "18mfc77xbi84iga9zrh227hl3jv7p0mbarxvz4qrws0fknsbx4r9"; })
+  (fetchNuGet { pname = "Microsoft.Data.Sqlite.Core"; version = "3.1.18"; sha256 = "1vh9jjpgqr33kyp72n7k6xkqsd0q978p84lf54rm50krlkx31q0h"; })
+  (fetchNuGet { pname = "Microsoft.DotNet.PlatformAbstractions"; version = "3.1.6"; sha256 = "0b9myd7gqbpaw9pkd2bx45jhik9mwj0f1ss57sk2cxmag2lkdws5"; })
+  (fetchNuGet { pname = "Microsoft.EntityFrameworkCore"; version = "3.1.0"; sha256 = "1l12lsk1xfrv5pjnm0b9w9kncgdh0pcjcbxl4zrsg82s7bs7dhda"; })
+  (fetchNuGet { pname = "Microsoft.EntityFrameworkCore"; version = "3.1.18"; sha256 = "1y3g71d2i3azsnb995379rspchhbr1ivi1b1kfm0gx8swrp1j1wy"; })
+  (fetchNuGet { pname = "Microsoft.EntityFrameworkCore"; version = "3.1.1"; sha256 = "1ymnxrd79fx4q3aq0d7m8dpx4gyqkbjm960knm4yd3889mlxkish"; })
+  (fetchNuGet { pname = "Microsoft.EntityFrameworkCore.Abstractions"; version = "3.1.0"; sha256 = "1bd6hilnwp47z3l14qspdxi5f5nhv6rivarc6w8wil425bq0h3pd"; })
+  (fetchNuGet { pname = "Microsoft.EntityFrameworkCore.Abstractions"; version = "3.1.18"; sha256 = "0d00d6wx2mm5bav39bjsikjq0sx6qmp183dbwimfda7wav2bwya8"; })
+  (fetchNuGet { pname = "Microsoft.EntityFrameworkCore.Abstractions"; version = "3.1.1"; sha256 = "0ddjfxp7k5jgk1fmzjcfxiijcf59mpi5y9lvcr7ly7dhkpx2gsg8"; })
+  (fetchNuGet { pname = "Microsoft.EntityFrameworkCore.Analyzers"; version = "3.1.0"; sha256 = "1pjn4wwhxgsiap7byld114kx6m0nm6696r8drspqic7lskm4y305"; })
+  (fetchNuGet { pname = "Microsoft.EntityFrameworkCore.Analyzers"; version = "3.1.18"; sha256 = "10h1w3lv3gxcf24hhy5av4fvdjxdm2iimzp7kz9zh9cm1jg5n0vl"; })
+  (fetchNuGet { pname = "Microsoft.EntityFrameworkCore.Analyzers"; version = "3.1.1"; sha256 = "0vh2i1wc8514wa5brspn53sa2l034cpjswsvi0d84dnb04aw3b4b"; })
+  (fetchNuGet { pname = "Microsoft.EntityFrameworkCore.Design"; version = "3.1.18"; sha256 = "0vfn4kni1sgcw8js60gc4cs3g6chfw1mar2jz07bvgjv8wxlv7qw"; })
+  (fetchNuGet { pname = "Microsoft.EntityFrameworkCore.Relational"; version = "3.1.0"; sha256 = "0javqw6c27ppcysigjvcjcw3mk0gg1pv2pmwfpvvryr1pb4a9n55"; })
+  (fetchNuGet { pname = "Microsoft.EntityFrameworkCore.Relational"; version = "3.1.18"; sha256 = "0mlq9gmxrmix68mdh0lv803cx15lzrhs5d9622vj8wwdlngg3xdx"; })
+  (fetchNuGet { pname = "Microsoft.EntityFrameworkCore.Relational"; version = "3.1.1"; sha256 = "1qzw1rd5isa45xbyyq9vg2p04rnbfb2dinfllaaf7qaxy7mhxv65"; })
+  (fetchNuGet { pname = "Microsoft.EntityFrameworkCore.Sqlite"; version = "3.1.18"; sha256 = "0fs2900masv6j7j8n4kc05n2g55k7cgkhfkp5vb9pn7s2aw90kzi"; })
+  (fetchNuGet { pname = "Microsoft.EntityFrameworkCore.Sqlite.Core"; version = "3.1.18"; sha256 = "1m6v8g8jacrsfdl3i5q82g3k9y4wb2r3fh739ih66nlv9jbb81q6"; })
+  (fetchNuGet { pname = "Microsoft.EntityFrameworkCore.SqlServer"; version = "3.1.18"; sha256 = "08slvfh5p06rwr1n93x44ka54f5qcnkc5b0qig887dxy4yl3kiwk"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Caching.Abstractions"; version = "3.1.0"; sha256 = "0j5m2a48rwyzzvbz0hpr2md35iv78b86zyqjnrjq0y4vb7sairc0"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Caching.Abstractions"; version = "3.1.18"; sha256 = "0qb3csiz02mh85x1yv0wh6x0c4c9d7kml5nhs9n6z0mykpfybqpc"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Caching.Abstractions"; version = "3.1.1"; sha256 = "1m303nrhcjydw8ij3fmf1w8zxpli84l6k1d4ml56yrpc1n6zxmjq"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Caching.Memory"; version = "3.1.0"; sha256 = "1hi61647apn25kqjcb37nqafp8fikymdrk43j3kxjbwwwx507jy1"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Caching.Memory"; version = "3.1.18"; sha256 = "0fdnk16nas3gdkcjqiq3h0rkqv6ajvbp7lvrssa21av258wnvm3w"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Caching.Memory"; version = "3.1.1"; sha256 = "0nyq1iwjql9w2w83sjimsry8chl53372rbvq9jwng3mdzv9qzni4"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Configuration"; version = "3.1.0"; sha256 = "1rszgz0rd5kvib5fscz6ss3pkxyjwqy0xpd4f2ypgzf5z5g5d398"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Configuration"; version = "3.1.18"; sha256 = "0fpvm1h9n0vib4fwvvify2zkc8yzgg8p2qbqrqlp5fd3ppqivjqh"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Configuration"; version = "3.1.1"; sha256 = "1dmhci4qlwqmfgya02yi02xzv31v8g45mq1c4ffigs8jq8qn4f77"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Configuration.Abstractions"; version = "3.1.0"; sha256 = "1f7h52kamljglx5k08ccryilvk6d6cvr9c26lcb6b2c091znzk0q"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Configuration.Abstractions"; version = "3.1.18"; sha256 = "1aycn9rwfygdaw5wnb68ql96sb6midm6mj4742dcl9ibkrgks43w"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Configuration.Abstractions"; version = "3.1.1"; sha256 = "1a1bixlm8wxf2fsr67qdm7k6p441sx2sfjpcjd3rm5df2v2y9zbv"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Configuration.Binder"; version = "3.1.0"; sha256 = "13jj7jxihiswmhmql7r5jydbca4x5qj6h7zq10z17gagys6dc7pw"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Configuration.Binder"; version = "3.1.18"; sha256 = "1bxcqfh75xypiqq2ljf1rwy7yq58a07g9g12jnlh4x7xba9xd4j0"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Configuration.Binder"; version = "3.1.1"; sha256 = "1brd1cxhkp5cg2wfkjkkyyvkzi4mdzyjafq94rbndzcxn9gxvz39"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.DependencyInjection"; version = "3.1.0"; sha256 = "1xc61dy07bn2q73mx1z3ylrw80xpa682qjby13gklnqq636a3gab"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.DependencyInjection"; version = "3.1.18"; sha256 = "0r8fs4pax5pyfny3ppav4v4by3l7r0xpkax9gvq91w3pzvlfvriz"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.DependencyInjection"; version = "3.1.1"; sha256 = "01x8a8djyxcqv3fhp1q647b9y720xbbp1922vw9by4zh8f0lzs2w"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.DependencyInjection.Abstractions"; version = "3.1.0"; sha256 = "1pvms778xkyv1a3gfwrxnh8ja769cxi416n7pcidn9wvg15ifvbh"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.DependencyInjection.Abstractions"; version = "3.1.18"; sha256 = "0kvxyhhs5k7xx51ihc8hppbzpcn34bdzmnp42gy2m359wl3iq0c3"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.DependencyInjection.Abstractions"; version = "3.1.1"; sha256 = "1k6k6h00p9hpr9jjq5vy4zwn9ggzldzm97gwjil6hpr3kxawb37n"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.DependencyModel"; version = "3.1.6"; sha256 = "13m2na8a5mglbbjjp0dxb8ifkf23grkyk1g8585mr7v6cbj098ac"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Logging"; version = "3.1.0"; sha256 = "1d3yhqj1rav7vswm747j7w8fh8paybji4rz941hhlq4b12mfqfh4"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Logging"; version = "3.1.18"; sha256 = "0llw82p6crp0329n3rsyrqka21c3dqyjk8lbk25y5848vzi0bzbv"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Logging"; version = "3.1.1"; sha256 = "1y78bn463mrl8vy7iwafrmq4x0vg4pqjd3xaiznfg9lpxjgjl9j3"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Logging.Abstractions"; version = "3.1.0"; sha256 = "1zyalrcksszmn9r5xjnirfh7847axncgzxkk3k5srbvlcch8fw8g"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Logging.Abstractions"; version = "3.1.18"; sha256 = "0pq1kw77zz9ygcdw87wxd1rkcij084jj1cgp6p4b8zpl0a73ba6b"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Logging.Abstractions"; version = "3.1.1"; sha256 = "0pyk6g2qs1lrjhj1qz4bqbqpbmbgqlah1b6ynlvv5bdsrb7157zf"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Options"; version = "3.1.0"; sha256 = "0akccwhpn93a4qrssyb3rszdsp3j4p9hlxbsb7yhqb78xydaqhyh"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Options"; version = "3.1.18"; sha256 = "0iv79m9grl28b5zcng14v5nrgic3rgy74ws9l92fw2f194qbdy6h"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Options"; version = "3.1.1"; sha256 = "15iik4hqm5ywzv9lvlfqk6d7drgdm87h6x9gliy9ks6snyhbnpb3"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Options.ConfigurationExtensions"; version = "3.1.18"; sha256 = "0id3s26s7grlzfvqmknz3ir7agns680ad8d0kv6mr9dfrqj6ca1l"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.PlatformAbstractions"; version = "1.1.0"; sha256 = "0r4j8v2vvp3kalvb11ny9cvpls3nrvqj0c81rxbkh99ynd2dbscp"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Primitives"; version = "3.1.0"; sha256 = "1w1y22njywwysi8qjnj4m83qhbq0jr4mmjib0hfawz6cwamh7xrb"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Primitives"; version = "3.1.18"; sha256 = "1xcwb09acn6w3jv3s0bp0f7q9vq3rzp7cg2jhbn3a9h9pzk8haa2"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Primitives"; version = "3.1.1"; sha256 = "07rkb1xl7y59qjg9j3bms0fi09gmjrf9f4ipckxlx64k8ciilw9f"; })
+  (fetchNuGet { pname = "Microsoft.Identity.Client"; version = "3.0.8"; sha256 = "0g7j08fqk8svch31jg0vg32chgmxgbsin0i85whsd42hkjd4l8lg"; })
+  (fetchNuGet { pname = "Microsoft.IdentityModel.JsonWebTokens"; version = "5.5.0"; sha256 = "0ahkybdfiwnj5h25j5x2dylz3wfg2194cgqmsiqkaz93gbqibyw0"; })
+  (fetchNuGet { pname = "Microsoft.IdentityModel.Logging"; version = "5.5.0"; sha256 = "1a3bvzaas5d653l0yphl95xclj4yvdz5v08g0psj9i137yncn639"; })
+  (fetchNuGet { pname = "Microsoft.IdentityModel.Protocols"; version = "5.5.0"; sha256 = "029i1fz9y5gzrh68364ga1wm7gmk4h58lkdp5g77rsxa24rhshpl"; })
+  (fetchNuGet { pname = "Microsoft.IdentityModel.Protocols.OpenIdConnect"; version = "5.5.0"; sha256 = "0hxh6j4z1ha7r0pnh9lnnx54h6s3lkj0dv99n2h5pcsk0pbx91kf"; })
+  (fetchNuGet { pname = "Microsoft.IdentityModel.Tokens"; version = "5.5.0"; sha256 = "1ixdbn6ia6df4qqg89ihcmjz5jjnp9jjcdjifqzaccy37bvxk8dj"; })
+  (fetchNuGet { pname = "Microsoft.NETCore.Platforms"; version = "1.0.1"; sha256 = "01al6cfxp68dscl15z7rxfw9zvhm64dncsw09a1vmdkacsa2v6lr"; })
+  (fetchNuGet { pname = "Microsoft.NETCore.Platforms"; version = "1.1.0"; sha256 = "08vh1r12g6ykjygq5d3vq09zylgb84l63k49jc4v8faw9g93iqqm"; })
+  (fetchNuGet { pname = "Microsoft.NETCore.Platforms"; version = "2.0.0"; sha256 = "1fk2fk2639i7nzy58m9dvpdnzql4vb8yl8vr19r2fp8lmj9w2jr0"; })
+  (fetchNuGet { pname = "Microsoft.NETCore.Platforms"; version = "2.1.2"; sha256 = "1507hnpr9my3z4w1r6xk5n0s1j3y6a2c2cnynj76za7cphxi1141"; })
+  (fetchNuGet { pname = "Microsoft.NETCore.Targets"; version = "1.0.1"; sha256 = "0ppdkwy6s9p7x9jix3v4402wb171cdiibq7js7i13nxpdky7074p"; })
+  (fetchNuGet { pname = "Microsoft.NETCore.Targets"; version = "1.1.0"; sha256 = "193xwf33fbm0ni3idxzbr5fdq3i2dlfgihsac9jj7whj0gd902nh"; })
+  (fetchNuGet { pname = "Microsoft.OData.Core"; version = "7.5.0"; sha256 = "0xl3pl7433w2qdcdqnizmwpzavsbip5fv2izw583b99zbyhjxzmx"; })
+  (fetchNuGet { pname = "Microsoft.OData.Edm"; version = "7.5.0"; sha256 = "1xsab22g60q04dscnvswzhjig5ydly37kq205dsk4jm4b1df9dip"; })
+  (fetchNuGet { pname = "Microsoft.Rest.ClientRuntime"; version = "2.3.11"; sha256 = "0iqxxyiyi057c92nlf2aiva59c13bhg93w2gp0qh0777gb750hbx"; })
+  (fetchNuGet { pname = "Microsoft.Rest.ClientRuntime.Azure"; version = "3.3.12"; sha256 = "01r0swv029wwxn1h4paqlyc4chmqg04wi2h0h74bh7lcgjsm9qb1"; })
+  (fetchNuGet { pname = "Microsoft.SourceLink.Common"; version = "1.0.0"; sha256 = "1zxkpx01zdv17c39iiy8fx25ran89n14qwddh1f140v1s4dn8z9c"; })
+  (fetchNuGet { pname = "Microsoft.SourceLink.GitHub"; version = "1.0.0"; sha256 = "029ixyaqn48cjza87m5qf0g1ynyhlm6irgbx1n09src9g666yhpd"; })
+  (fetchNuGet { pname = "Microsoft.Spatial"; version = "7.2.0"; sha256 = "15a2lv7305729mdffh6r2qff5c1dk9b0w5a60kclw1a580vipzk2"; })
+  (fetchNuGet { pname = "Microsoft.Spatial"; version = "7.5.0"; sha256 = "1zxjy5f4bksgf0ilgrqhxpy5g1nzbz54pcp9dx0smvc9yqlacy97"; })
+  (fetchNuGet { pname = "Microsoft.Win32.Primitives"; version = "4.0.1"; sha256 = "1n8ap0cmljbqskxpf8fjzn7kh1vvlndsa75k01qig26mbw97k2q7"; })
+  (fetchNuGet { pname = "Microsoft.Win32.Primitives"; version = "4.3.0"; sha256 = "0j0c1wj4ndj21zsgivsc24whiya605603kxrbiw6wkfdync464wq"; })
+  (fetchNuGet { pname = "Microsoft.Win32.Registry"; version = "4.5.0"; sha256 = "1zapbz161ji8h82xiajgriq6zgzmb1f3ar517p2h63plhsq5gh2q"; })
+  (fetchNuGet { pname = "MySqlConnector"; version = "0.61.0"; sha256 = "0b0mc41dsih4p1ky3kcmibsz4bw14w439nraq5732wjfkq2sqdxg"; })
+  (fetchNuGet { pname = "NETStandard.Library"; version = "2.0.3"; sha256 = "1fn9fxppfcg4jgypp2pmrpr6awl3qz1xmnri0cygpkwvyx27df1y"; })
+  (fetchNuGet { pname = "Newtonsoft.Json"; version = "10.0.1"; sha256 = "15ncqic3p2rzs8q8ppi0irl2miq75kilw4lh8yfgjq96id0ds3hv"; })
+  (fetchNuGet { pname = "Newtonsoft.Json"; version = "10.0.2"; sha256 = "03zb1k50mgzvznp9sfv371fdvx82bqpgq99dj61paan8a30prj6y"; })
+  (fetchNuGet { pname = "Newtonsoft.Json"; version = "11.0.2"; sha256 = "1784xi44f4k8v1fr696hsccmwpy94bz7kixxqlri98zhcxn406b2"; })
+  (fetchNuGet { pname = "Newtonsoft.Json"; version = "9.0.1"; sha256 = "0mcy0i7pnfpqm4pcaiyzzji4g0c8i3a5gjz28rrr28110np8304r"; })
+  (fetchNuGet { pname = "Npgsql"; version = "4.1.3"; sha256 = "08515af6g0d8v1d2r493xdxc74y1bg8ngbhck0wq4jhh109ndg97"; })
+  (fetchNuGet { pname = "Npgsql.EntityFrameworkCore.PostgreSQL"; version = "3.1.1.2"; sha256 = "0ng4cyzmbh1x8jshx55x3h5azif4zb3v4d3n3sxkqavbq8j2phhs"; })
+  (fetchNuGet { pname = "NuGet.Common"; version = "5.10.0"; sha256 = "0qy6blgppgvxpfcricmvva3qzddk18dza5vy851jrbqshvf9g7kx"; })
+  (fetchNuGet { pname = "NuGet.Configuration"; version = "5.10.0"; sha256 = "0xb1n94lrwa6k83i9xcsq68202086p2gj74gzlbhlvb8c2pw6lbb"; })
+  (fetchNuGet { pname = "NuGet.Frameworks"; version = "5.10.0"; sha256 = "0gb6n8rg2jpjp52icgpb3wjdfs3qllh5vbcz8hbcix3l7dncy3v2"; })
+  (fetchNuGet { pname = "NuGet.Packaging"; version = "5.10.0"; sha256 = "11g0v061axhp0nisclq5cm2mc92d69z92giz9l40ih478c5nishw"; })
+  (fetchNuGet { pname = "NuGet.Protocol"; version = "5.10.0"; sha256 = "0cs9qp169zx6g2w5bzrlhxv0q1i8mb8dxlb2nkiq7pkvah86rxkc"; })
+  (fetchNuGet { pname = "NuGet.Versioning"; version = "5.10.0"; sha256 = "10vvw6vjpx0c26rlxh7dnpyp4prahn25717ccd8bzkjmyzhm90cs"; })
+  (fetchNuGet { pname = "Pomelo.EntityFrameworkCore.MySql"; version = "3.1.0"; sha256 = "0a8ysdwsa0kds5zbfmcdnk8imaqf2hisjms951h1smnlnii9kyds"; })
+  (fetchNuGet { pname = "Pomelo.JsonObject"; version = "2.2.1"; sha256 = "1w6s9wjbsyvq8cnqknkdzm9chnv0g5gcsrq5i94zp6br9vg7c627"; })
+  (fetchNuGet { pname = "runtime.debian.8-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; sha256 = "16rnxzpk5dpbbl1x354yrlsbvwylrq456xzpsha1n9y3glnhyx9d"; })
+  (fetchNuGet { pname = "runtime.debian.8-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.2"; sha256 = "0rwpqngkqiapqc5c2cpkj7idhngrgss5qpnqg0yh40mbyflcxf8i"; })
+  (fetchNuGet { pname = "runtime.fedora.23-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; sha256 = "0hkg03sgm2wyq8nqk6dbm9jh5vcq57ry42lkqdmfklrw89lsmr59"; })
+  (fetchNuGet { pname = "runtime.fedora.23-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.2"; sha256 = "1n06gxwlinhs0w7s8a94r1q3lwqzvynxwd3mp10ws9bg6gck8n4r"; })
+  (fetchNuGet { pname = "runtime.fedora.24-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; sha256 = "0c2p354hjx58xhhz7wv6div8xpi90sc6ibdm40qin21bvi7ymcaa"; })
+  (fetchNuGet { pname = "runtime.fedora.24-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.2"; sha256 = "0404wqrc7f2yc0wxv71y3nnybvqx8v4j9d47hlscxy759a525mc3"; })
+  (fetchNuGet { pname = "runtime.native.System"; version = "4.0.0"; sha256 = "1ppk69xk59ggacj9n7g6fyxvzmk1g5p4fkijm0d7xqfkig98qrkf"; })
+  (fetchNuGet { pname = "runtime.native.System"; version = "4.3.0"; sha256 = "15hgf6zaq9b8br2wi1i3x0zvmk410nlmsmva9p0bbg73v6hml5k4"; })
+  (fetchNuGet { pname = "runtime.native.System.Data.SqlClient.sni"; version = "4.4.0"; sha256 = "15wnpyy506q3vyk1yzdjjf49zpdynr7ghh0x5fbz4pcc1if0p9ky"; })
+  (fetchNuGet { pname = "runtime.native.System.Net.Http"; version = "4.0.1"; sha256 = "1hgv2bmbaskx77v8glh7waxws973jn4ah35zysnkxmf0196sfxg6"; })
+  (fetchNuGet { pname = "runtime.native.System.Net.Http"; version = "4.3.0"; sha256 = "1n6rgz5132lcibbch1qlf0g9jk60r0kqv087hxc0lisy50zpm7kk"; })
+  (fetchNuGet { pname = "runtime.native.System.Net.Security"; version = "4.3.0"; sha256 = "0dnqjhw445ay3chpia9p6vy4w2j6s9vy3hxszqvdanpvvyaxijr3"; })
+  (fetchNuGet { pname = "runtime.native.System.Security.Cryptography"; version = "4.0.0"; sha256 = "0k57aa2c3b10wl3hfqbgrl7xq7g8hh3a3ir44b31dn5p61iiw3z9"; })
+  (fetchNuGet { pname = "runtime.native.System.Security.Cryptography.Apple"; version = "4.3.0"; sha256 = "1b61p6gw1m02cc1ry996fl49liiwky6181dzr873g9ds92zl326q"; })
+  (fetchNuGet { pname = "runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; sha256 = "18pzfdlwsg2nb1jjjjzyb5qlgy6xjxzmhnfaijq5s2jw3cm3ab97"; })
+  (fetchNuGet { pname = "runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.2"; sha256 = "0zy5r25jppz48i2bkg8b9lfig24xixg6nm3xyr1379zdnqnpm8f6"; })
+  (fetchNuGet { pname = "runtime.opensuse.13.2-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; sha256 = "0qyynf9nz5i7pc26cwhgi8j62ps27sqmf78ijcfgzab50z9g8ay3"; })
+  (fetchNuGet { pname = "runtime.opensuse.13.2-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.2"; sha256 = "096ch4n4s8k82xga80lfmpimpzahd2ip1mgwdqgar0ywbbl6x438"; })
+  (fetchNuGet { pname = "runtime.opensuse.42.1-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; sha256 = "1klrs545awhayryma6l7g2pvnp9xy4z0r1i40r80zb45q3i9nbyf"; })
+  (fetchNuGet { pname = "runtime.opensuse.42.1-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.2"; sha256 = "1dm8fifl7rf1gy7lnwln78ch4rw54g0pl5g1c189vawavll7p6rj"; })
+  (fetchNuGet { pname = "runtime.osx.10.10-x64.runtime.native.System.Security.Cryptography.Apple"; version = "4.3.0"; sha256 = "10yc8jdrwgcl44b4g93f1ds76b176bajd3zqi2faf5rvh1vy9smi"; })
+  (fetchNuGet { pname = "runtime.osx.10.10-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; sha256 = "0zcxjv5pckplvkg0r6mw3asggm7aqzbdjimhvsasb0cgm59x09l3"; })
+  (fetchNuGet { pname = "runtime.osx.10.10-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.2"; sha256 = "1m9z1k9kzva9n9kwinqxl97x2vgl79qhqjlv17k9s2ymcyv2bwr6"; })
+  (fetchNuGet { pname = "runtime.rhel.7-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; sha256 = "0vhynn79ih7hw7cwjazn87rm9z9fj0rvxgzlab36jybgcpcgphsn"; })
+  (fetchNuGet { pname = "runtime.rhel.7-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.2"; sha256 = "1cpx56mcfxz7cpn57wvj18sjisvzq8b5vd9rw16ihd2i6mcp3wa1"; })
+  (fetchNuGet { pname = "runtime.ubuntu.14.04-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; sha256 = "160p68l2c7cqmyqjwxydcvgw7lvl1cr0znkw8fp24d1by9mqc8p3"; })
+  (fetchNuGet { pname = "runtime.ubuntu.14.04-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.2"; sha256 = "15gsm1a8jdmgmf8j5v1slfz8ks124nfdhk2vxs2rw3asrxalg8hi"; })
+  (fetchNuGet { pname = "runtime.ubuntu.16.04-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; sha256 = "15zrc8fgd8zx28hdghcj5f5i34wf3l6bq5177075m2bc2j34jrqy"; })
+  (fetchNuGet { pname = "runtime.ubuntu.16.04-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.2"; sha256 = "0q0n5q1r1wnqmr5i5idsrd9ywl33k0js4pngkwq9p368mbxp8x1w"; })
+  (fetchNuGet { pname = "runtime.ubuntu.16.10-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; sha256 = "1p4dgxax6p7rlgj4q73k73rslcnz4wdcv8q2flg1s8ygwcm58ld5"; })
+  (fetchNuGet { pname = "runtime.ubuntu.16.10-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.2"; sha256 = "1x0g58pbpjrmj2x2qw17rdwwnrcl0wvim2hdwz48lixvwvp22n9c"; })
+  (fetchNuGet { pname = "runtime.win-arm64.runtime.native.System.Data.SqlClient.sni"; version = "4.4.0"; sha256 = "07byf1iyqb7jkb17sp0mmjk46fwq6fx8mlpzywxl7qk09sma44gk"; })
+  (fetchNuGet { pname = "runtime.win-x64.runtime.native.System.Data.SqlClient.sni"; version = "4.4.0"; sha256 = "0167s4mpq8bzk3y11pylnynzjr2nc84w96al9x4l8yrf34ccm18y"; })
+  (fetchNuGet { pname = "runtime.win-x86.runtime.native.System.Data.SqlClient.sni"; version = "4.4.0"; sha256 = "0k3rkfrlm9jjz56dra61jgxinb8zsqlqzik2sjwz7f8v6z6ddycc"; })
+  (fetchNuGet { pname = "SQLitePCLRaw.bundle_e_sqlite3"; version = "2.0.2"; sha256 = "00p7n7ndmmh45fhhd3clb11igpzklm1n7r50sdrgnbi5yifv1lxl"; })
+  (fetchNuGet { pname = "SQLitePCLRaw.core"; version = "2.0.2"; sha256 = "11mnbnsiirpgmilskqh1issvgzgg08ndq3p3nkrw73hyqr7kl958"; })
+  (fetchNuGet { pname = "SQLitePCLRaw.lib.e_sqlite3"; version = "2.0.2"; sha256 = "0967w6r6n94hj0fma3kidb9fx1m2p3fgrw6gpsy6q6jbb33qw6vj"; })
+  (fetchNuGet { pname = "SQLitePCLRaw.provider.dynamic_cdecl"; version = "2.0.2"; sha256 = "1lzs8yfjygrwfm3hjmkhnbnpsjzq53ijwx9whmii2r9kjg2a46if"; })
+  (fetchNuGet { pname = "SQLitePCLRaw.provider.e_sqlite3"; version = "2.0.2"; sha256 = "0ak8jlkva1mnmvyvwhk9zmc4c5b08n4a7l8g9g5mj3ly161hfzm6"; })
+  (fetchNuGet { pname = "System.Buffers"; version = "4.4.0"; sha256 = "183f8063w8zqn99pv0ni0nnwh7fgx46qzxamwnans55hhs2l0g19"; })
+  (fetchNuGet { pname = "System.Buffers"; version = "4.5.0"; sha256 = "1ywfqn4md6g3iilpxjn5dsr0f5lx6z0yvhqp4pgjcamygg73cz2c"; })
+  (fetchNuGet { pname = "System.Buffers"; version = "4.5.1"; sha256 = "04kb1mdrlcixj9zh1xdi5as0k0qi8byr5mi3p3jcxx72qz93s2y3"; })
+  (fetchNuGet { pname = "System.Collections"; version = "4.0.11"; sha256 = "1ga40f5lrwldiyw6vy67d0sg7jd7ww6kgwbksm19wrvq9hr0bsm6"; })
+  (fetchNuGet { pname = "System.Collections"; version = "4.3.0"; sha256 = "19r4y64dqyrq6k4706dnyhhw7fs24kpp3awak7whzss39dakpxk9"; })
+  (fetchNuGet { pname = "System.Collections.Concurrent"; version = "4.0.12"; sha256 = "07y08kvrzpak873pmyxs129g1ch8l27zmg51pcyj2jvq03n0r0fc"; })
+  (fetchNuGet { pname = "System.Collections.Concurrent"; version = "4.3.0"; sha256 = "0wi10md9aq33jrkh2c24wr2n9hrpyamsdhsxdcnf43b7y86kkii8"; })
+  (fetchNuGet { pname = "System.Collections.Immutable"; version = "1.5.0"; sha256 = "1d5gjn5afnrf461jlxzawcvihz195gayqpcfbv6dd7pxa9ialn06"; })
+  (fetchNuGet { pname = "System.Collections.Immutable"; version = "1.7.0"; sha256 = "1gik4sn9jsi1wcy1pyyp0r4sn2g17cwrsh24b2d52vif8p2h24zx"; })
+  (fetchNuGet { pname = "System.Collections.Immutable"; version = "1.7.1"; sha256 = "1nh4nlxfc7lbnbl86wwk1a3jwl6myz5j6hvgh5sp4krim9901hsq"; })
+  (fetchNuGet { pname = "System.Collections.NonGeneric"; version = "4.0.1"; sha256 = "19994r5y5bpdhj7di6w047apvil8lh06lh2c2yv9zc4fc5g9bl4d"; })
+  (fetchNuGet { pname = "System.Collections.NonGeneric"; version = "4.3.0"; sha256 = "07q3k0hf3mrcjzwj8fwk6gv3n51cb513w4mgkfxzm3i37sc9kz7k"; })
+  (fetchNuGet { pname = "System.Collections.Specialized"; version = "4.0.1"; sha256 = "1wbv7y686p5x169rnaim7sln67ivmv6r57falrnx8aap9y33mam9"; })
+  (fetchNuGet { pname = "System.Collections.Specialized"; version = "4.3.0"; sha256 = "1sdwkma4f6j85m3dpb53v9vcgd0zyc9jb33f8g63byvijcj39n20"; })
+  (fetchNuGet { pname = "System.ComponentModel"; version = "4.3.0"; sha256 = "0986b10ww3nshy30x9sjyzm0jx339dkjxjj3401r3q0f6fx2wkcb"; })
+  (fetchNuGet { pname = "System.ComponentModel.Annotations"; version = "4.7.0"; sha256 = "06x1m46ddxj0ng28d7gry9gjkqdg2kp89jyf480g5gznyybbs49z"; })
+  (fetchNuGet { pname = "System.ComponentModel.Primitives"; version = "4.3.0"; sha256 = "1svfmcmgs0w0z9xdw2f2ps05rdxmkxxhf0l17xk9l1l8xfahkqr0"; })
+  (fetchNuGet { pname = "System.ComponentModel.TypeConverter"; version = "4.3.0"; sha256 = "17ng0p7v3nbrg3kycz10aqrrlw4lz9hzhws09pfh8gkwicyy481x"; })
+  (fetchNuGet { pname = "System.Configuration.ConfigurationManager"; version = "4.5.0"; sha256 = "1frpy24mn6q7hgwayj98kkx89z861f5dmia4j6zc0a2ydgx8x02c"; })
+  (fetchNuGet { pname = "System.Diagnostics.Debug"; version = "4.0.11"; sha256 = "0gmjghrqmlgzxivd2xl50ncbglb7ljzb66rlx8ws6dv8jm0d5siz"; })
+  (fetchNuGet { pname = "System.Diagnostics.Debug"; version = "4.3.0"; sha256 = "00yjlf19wjydyr6cfviaph3vsjzg3d5nvnya26i2fvfg53sknh3y"; })
+  (fetchNuGet { pname = "System.Diagnostics.DiagnosticSource"; version = "4.0.0"; sha256 = "1n6c3fbz7v8d3pn77h4v5wvsfrfg7v1c57lg3nff3cjyh597v23m"; })
+  (fetchNuGet { pname = "System.Diagnostics.DiagnosticSource"; version = "4.3.0"; sha256 = "0z6m3pbiy0qw6rn3n209rrzf9x1k4002zh90vwcrsym09ipm2liq"; })
+  (fetchNuGet { pname = "System.Diagnostics.DiagnosticSource"; version = "4.5.0"; sha256 = "1y8m0p3127nak5yspapfnz25qc9x53gqpvwr3hdpsvrcd2r1pgyj"; })
+  (fetchNuGet { pname = "System.Diagnostics.DiagnosticSource"; version = "4.7.0"; sha256 = "0cr0v5dz8l5ackxv6b772fjcyj2nimqmrmzanjs4cw2668v568n1"; })
+  (fetchNuGet { pname = "System.Diagnostics.DiagnosticSource"; version = "4.7.1"; sha256 = "1mivaifniyrqwlnvzsfaxzrh2sd981bwzs3cbvs5wi7jjzbcqr4p"; })
+  (fetchNuGet { pname = "System.Diagnostics.Tools"; version = "4.0.1"; sha256 = "19cknvg07yhakcvpxg3cxa0bwadplin6kyxd8mpjjpwnp56nl85x"; })
+  (fetchNuGet { pname = "System.Diagnostics.Tools"; version = "4.3.0"; sha256 = "0in3pic3s2ddyibi8cvgl102zmvp9r9mchh82ns9f0ms4basylw1"; })
+  (fetchNuGet { pname = "System.Diagnostics.TraceSource"; version = "4.0.0"; sha256 = "1mc7r72xznczzf6mz62dm8xhdi14if1h8qgx353xvhz89qyxsa3h"; })
+  (fetchNuGet { pname = "System.Diagnostics.Tracing"; version = "4.1.0"; sha256 = "1d2r76v1x610x61ahfpigda89gd13qydz6vbwzhpqlyvq8jj6394"; })
+  (fetchNuGet { pname = "System.Diagnostics.Tracing"; version = "4.3.0"; sha256 = "1m3bx6c2s958qligl67q7grkwfz3w53hpy7nc97mh6f7j5k168c4"; })
+  (fetchNuGet { pname = "System.Dynamic.Runtime"; version = "4.0.11"; sha256 = "1pla2dx8gkidf7xkciig6nifdsb494axjvzvann8g2lp3dbqasm9"; })
+  (fetchNuGet { pname = "System.Dynamic.Runtime"; version = "4.3.0"; sha256 = "1d951hrvrpndk7insiag80qxjbf2y0y39y8h5hnq9612ws661glk"; })
+  (fetchNuGet { pname = "System.Formats.Asn1"; version = "5.0.0"; sha256 = "1axc8z0839yvqi2cb63l73l6d9j6wd20lsbdymwddz9hvrsgfwpn"; })
+  (fetchNuGet { pname = "System.Globalization"; version = "4.0.11"; sha256 = "070c5jbas2v7smm660zaf1gh0489xanjqymkvafcs4f8cdrs1d5d"; })
+  (fetchNuGet { pname = "System.Globalization"; version = "4.3.0"; sha256 = "1cp68vv683n6ic2zqh2s1fn4c2sd87g5hpp6l4d4nj4536jz98ki"; })
+  (fetchNuGet { pname = "System.Globalization.Calendars"; version = "4.0.1"; sha256 = "0bv0alrm2ck2zk3rz25lfyk9h42f3ywq77mx1syl6vvyncnpg4qh"; })
+  (fetchNuGet { pname = "System.Globalization.Calendars"; version = "4.3.0"; sha256 = "1xwl230bkakzzkrggy1l1lxmm3xlhk4bq2pkv790j5lm8g887lxq"; })
+  (fetchNuGet { pname = "System.Globalization.Extensions"; version = "4.0.1"; sha256 = "0hjhdb5ri8z9l93bw04s7ynwrjrhx2n0p34sf33a9hl9phz69fyc"; })
+  (fetchNuGet { pname = "System.Globalization.Extensions"; version = "4.3.0"; sha256 = "02a5zfxavhv3jd437bsncbhd2fp1zv4gxzakp1an9l6kdq1mcqls"; })
+  (fetchNuGet { pname = "System.IdentityModel.Tokens.Jwt"; version = "5.5.0"; sha256 = "0p6ybl5ik2glwcfhiqlqdggl0qd6027kdxaqy5xmp7qq055qiq6k"; })
+  (fetchNuGet { pname = "System.Interactive.Async"; version = "3.1.1"; sha256 = "03iq20gq0n2b2sdzs5jhxf46nzkfgvzip6q5248vka2rcvn1yanh"; })
+  (fetchNuGet { pname = "System.IO"; version = "4.1.0"; sha256 = "1g0yb8p11vfd0kbkyzlfsbsp5z44lwsvyc0h3dpw6vqnbi035ajp"; })
+  (fetchNuGet { pname = "System.IO"; version = "4.3.0"; sha256 = "05l9qdrzhm4s5dixmx68kxwif4l99ll5gqmh7rqgw554fx0agv5f"; })
+  (fetchNuGet { pname = "System.IO.FileSystem"; version = "4.0.1"; sha256 = "0kgfpw6w4djqra3w5crrg8xivbanh1w9dh3qapb28q060wb9flp1"; })
+  (fetchNuGet { pname = "System.IO.FileSystem"; version = "4.3.0"; sha256 = "0z2dfrbra9i6y16mm9v1v6k47f0fm617vlb7s5iybjjsz6g1ilmw"; })
+  (fetchNuGet { pname = "System.IO.FileSystem.Primitives"; version = "4.0.1"; sha256 = "1s0mniajj3lvbyf7vfb5shp4ink5yibsx945k6lvxa96r8la1612"; })
+  (fetchNuGet { pname = "System.IO.FileSystem.Primitives"; version = "4.3.0"; sha256 = "0j6ndgglcf4brg2lz4wzsh1av1gh8xrzdsn9f0yznskhqn1xzj9c"; })
+  (fetchNuGet { pname = "System.Linq"; version = "4.1.0"; sha256 = "1ppg83svb39hj4hpp5k7kcryzrf3sfnm08vxd5sm2drrijsla2k5"; })
+  (fetchNuGet { pname = "System.Linq"; version = "4.3.0"; sha256 = "1w0gmba695rbr80l1k2h4mrwzbzsyfl2z4klmpbsvsg5pm4a56s7"; })
+  (fetchNuGet { pname = "System.Linq.Expressions"; version = "4.1.0"; sha256 = "1gpdxl6ip06cnab7n3zlcg6mqp7kknf73s8wjinzi4p0apw82fpg"; })
+  (fetchNuGet { pname = "System.Linq.Expressions"; version = "4.3.0"; sha256 = "0ky2nrcvh70rqq88m9a5yqabsl4fyd17bpr63iy2mbivjs2nyypv"; })
+  (fetchNuGet { pname = "System.Linq.Queryable"; version = "4.0.1"; sha256 = "11jn9k34g245yyf260gr3ldzvaqa9477w2c5nhb1p8vjx4xm3qaw"; })
+  (fetchNuGet { pname = "System.Memory"; version = "4.5.0"; sha256 = "1layqpcx1q4l805fdnj2dfqp6ncx2z42ca06rgsr6ikq4jjgbv30"; })
+  (fetchNuGet { pname = "System.Memory"; version = "4.5.1"; sha256 = "0f07d7hny38lq9w69wx4lxkn4wszrqf9m9js6fh9is645csm167c"; })
+  (fetchNuGet { pname = "System.Memory"; version = "4.5.2"; sha256 = "1g24dwqfcmf4gpbgbhaw1j49xmpsz389l6bw2xxbsmnzvsf860ld"; })
+  (fetchNuGet { pname = "System.Memory"; version = "4.5.3"; sha256 = "0naqahm3wljxb5a911d37mwjqjdxv9l0b49p5dmfyijvni2ppy8a"; })
+  (fetchNuGet { pname = "System.Memory"; version = "4.5.4"; sha256 = "14gbbs22mcxwggn0fcfs1b062521azb9fbb7c113x0mq6dzq9h6y"; })
+  (fetchNuGet { pname = "System.Net.Http"; version = "4.1.0"; sha256 = "1i5rqij1icg05j8rrkw4gd4pgia1978mqhjzhsjg69lvwcdfg8yb"; })
+  (fetchNuGet { pname = "System.Net.Http"; version = "4.3.0"; sha256 = "1i4gc757xqrzflbk7kc5ksn20kwwfjhw9w7pgdkn19y3cgnl302j"; })
+  (fetchNuGet { pname = "System.Net.NameResolution"; version = "4.0.0"; sha256 = "0dj3pvpv069nyia28gkl4a0fb7q33hbxz2dg25qvpah3l7pbl0qh"; })
+  (fetchNuGet { pname = "System.Net.NameResolution"; version = "4.3.0"; sha256 = "15r75pwc0rm3vvwsn8rvm2krf929mjfwliv0mpicjnii24470rkq"; })
+  (fetchNuGet { pname = "System.Net.NetworkInformation"; version = "4.1.0"; sha256 = "17ia8gyr0aq76z9cv37yjmpna7nx30xfppw0lifvi9s2q3yjspd2"; })
+  (fetchNuGet { pname = "System.Net.Primitives"; version = "4.0.11"; sha256 = "10xzzaynkzkakp7jai1ik3r805zrqjxiz7vcagchyxs2v26a516r"; })
+  (fetchNuGet { pname = "System.Net.Primitives"; version = "4.3.0"; sha256 = "0c87k50rmdgmxx7df2khd9qj7q35j9rzdmm2572cc55dygmdk3ii"; })
+  (fetchNuGet { pname = "System.Net.Requests"; version = "4.0.11"; sha256 = "13mka55sa6dg6nw4zdrih44gnp8hnj5azynz47ljsh2791lz3d9h"; })
+  (fetchNuGet { pname = "System.Net.Security"; version = "4.3.2"; sha256 = "1aw1ca1vssqrillrh4qkarx0lxwc8wcaqdkfdima8376wb98j2q8"; })
+  (fetchNuGet { pname = "System.Net.Sockets"; version = "4.1.0"; sha256 = "1385fvh8h29da5hh58jm1v78fzi9fi5vj93vhlm2kvqpfahvpqls"; })
+  (fetchNuGet { pname = "System.Net.WebHeaderCollection"; version = "4.0.1"; sha256 = "10bxpxj80c4z00z3ksrfswspq9qqsw8jwxcbzvymzycb97m9b55q"; })
+  (fetchNuGet { pname = "System.Numerics.Vectors"; version = "4.4.0"; sha256 = "0rdvma399070b0i46c4qq1h2yvjj3k013sqzkilz4bz5cwmx1rba"; })
+  (fetchNuGet { pname = "System.Numerics.Vectors"; version = "4.5.0"; sha256 = "1kzrj37yzawf1b19jq0253rcs8hsq1l2q8g69d7ipnhzb0h97m59"; })
+  (fetchNuGet { pname = "System.ObjectModel"; version = "4.0.12"; sha256 = "1sybkfi60a4588xn34nd9a58png36i0xr4y4v4kqpg8wlvy5krrj"; })
+  (fetchNuGet { pname = "System.ObjectModel"; version = "4.3.0"; sha256 = "191p63zy5rpqx7dnrb3h7prvgixmk168fhvvkkvhlazncf8r3nc2"; })
+  (fetchNuGet { pname = "System.Private.DataContractSerialization"; version = "4.3.0"; sha256 = "06fjipqvjp559rrm825x6pll8gimdj9x1n3larigh5hsm584gndw"; })
+  (fetchNuGet { pname = "System.Reflection"; version = "4.1.0"; sha256 = "1js89429pfw79mxvbzp8p3q93il6rdff332hddhzi5wqglc4gml9"; })
+  (fetchNuGet { pname = "System.Reflection"; version = "4.3.0"; sha256 = "0xl55k0mw8cd8ra6dxzh974nxif58s3k1rjv1vbd7gjbjr39j11m"; })
+  (fetchNuGet { pname = "System.Reflection.Emit"; version = "4.0.1"; sha256 = "0ydqcsvh6smi41gyaakglnv252625hf29f7kywy2c70nhii2ylqp"; })
+  (fetchNuGet { pname = "System.Reflection.Emit"; version = "4.3.0"; sha256 = "11f8y3qfysfcrscjpjym9msk7lsfxkk4fmz9qq95kn3jd0769f74"; })
+  (fetchNuGet { pname = "System.Reflection.Emit.ILGeneration"; version = "4.0.1"; sha256 = "1pcd2ig6bg144y10w7yxgc9d22r7c7ww7qn1frdfwgxr24j9wvv0"; })
+  (fetchNuGet { pname = "System.Reflection.Emit.ILGeneration"; version = "4.3.0"; sha256 = "0w1n67glpv8241vnpz1kl14sy7zlnw414aqwj4hcx5nd86f6994q"; })
+  (fetchNuGet { pname = "System.Reflection.Emit.Lightweight"; version = "4.0.1"; sha256 = "1s4b043zdbx9k39lfhvsk68msv1nxbidhkq6nbm27q7sf8xcsnxr"; })
+  (fetchNuGet { pname = "System.Reflection.Emit.Lightweight"; version = "4.3.0"; sha256 = "0ql7lcakycrvzgi9kxz1b3lljd990az1x6c4jsiwcacrvimpib5c"; })
+  (fetchNuGet { pname = "System.Reflection.Extensions"; version = "4.0.1"; sha256 = "0m7wqwq0zqq9gbpiqvgk3sr92cbrw7cp3xn53xvw7zj6rz6fdirn"; })
+  (fetchNuGet { pname = "System.Reflection.Extensions"; version = "4.3.0"; sha256 = "02bly8bdc98gs22lqsfx9xicblszr2yan7v2mmw3g7hy6miq5hwq"; })
+  (fetchNuGet { pname = "System.Reflection.Metadata"; version = "1.6.0"; sha256 = "1wdbavrrkajy7qbdblpbpbalbdl48q3h34cchz24gvdgyrlf15r4"; })
+  (fetchNuGet { pname = "System.Reflection.Primitives"; version = "4.0.1"; sha256 = "1bangaabhsl4k9fg8khn83wm6yial8ik1sza7401621jc6jrym28"; })
+  (fetchNuGet { pname = "System.Reflection.Primitives"; version = "4.3.0"; sha256 = "04xqa33bld78yv5r93a8n76shvc8wwcdgr1qvvjh959g3rc31276"; })
+  (fetchNuGet { pname = "System.Reflection.TypeExtensions"; version = "4.1.0"; sha256 = "1bjli8a7sc7jlxqgcagl9nh8axzfl11f4ld3rjqsyxc516iijij7"; })
+  (fetchNuGet { pname = "System.Reflection.TypeExtensions"; version = "4.3.0"; sha256 = "0y2ssg08d817p0vdag98vn238gyrrynjdj4181hdg780sif3ykp1"; })
+  (fetchNuGet { pname = "System.Resources.ResourceManager"; version = "4.0.1"; sha256 = "0b4i7mncaf8cnai85jv3wnw6hps140cxz8vylv2bik6wyzgvz7bi"; })
+  (fetchNuGet { pname = "System.Resources.ResourceManager"; version = "4.3.0"; sha256 = "0sjqlzsryb0mg4y4xzf35xi523s4is4hz9q4qgdvlvgivl7qxn49"; })
+  (fetchNuGet { pname = "System.Runtime"; version = "4.1.0"; sha256 = "02hdkgk13rvsd6r9yafbwzss8kr55wnj8d5c7xjnp8gqrwc8sn0m"; })
+  (fetchNuGet { pname = "System.Runtime"; version = "4.3.0"; sha256 = "066ixvgbf2c929kgknshcxqj6539ax7b9m570cp8n179cpfkapz7"; })
+  (fetchNuGet { pname = "System.Runtime.Caching"; version = "4.5.0"; sha256 = "07ijp8j0cplcw1ns0fpkfsavppask164jn51lasiji4sfkjy592r"; })
+  (fetchNuGet { pname = "System.Runtime.CompilerServices.Unsafe"; version = "4.5.0"; sha256 = "17labczwqk3jng3kkky73m0jhi8wc21vbl7cz5c0hj2p1dswin43"; })
+  (fetchNuGet { pname = "System.Runtime.CompilerServices.Unsafe"; version = "4.5.2"; sha256 = "1vz4275fjij8inf31np78hw50al8nqkngk04p3xv5n4fcmf1grgi"; })
+  (fetchNuGet { pname = "System.Runtime.CompilerServices.Unsafe"; version = "4.5.3"; sha256 = "1afi6s2r1mh1kygbjmfba6l4f87pi5sg13p4a48idqafli94qxln"; })
+  (fetchNuGet { pname = "System.Runtime.CompilerServices.Unsafe"; version = "4.6.0"; sha256 = "0xmzi2gpbmgyfr75p24rqqsba3cmrqgmcv45lsqp5amgrdwd0f0m"; })
+  (fetchNuGet { pname = "System.Runtime.CompilerServices.Unsafe"; version = "4.7.0"; sha256 = "16r6sn4czfjk8qhnz7bnqlyiaaszr0ihinb7mq9zzr1wba257r54"; })
+  (fetchNuGet { pname = "System.Runtime.CompilerServices.Unsafe"; version = "4.7.1"; sha256 = "119br3pd85lq8zcgh4f60jzmv1g976q1kdgi3hvqdlhfbw6siz2j"; })
+  (fetchNuGet { pname = "System.Runtime.Extensions"; version = "4.1.0"; sha256 = "0rw4rm4vsm3h3szxp9iijc3ksyviwsv6f63dng3vhqyg4vjdkc2z"; })
+  (fetchNuGet { pname = "System.Runtime.Extensions"; version = "4.3.0"; sha256 = "1ykp3dnhwvm48nap8q23893hagf665k0kn3cbgsqpwzbijdcgc60"; })
+  (fetchNuGet { pname = "System.Runtime.Handles"; version = "4.0.1"; sha256 = "1g0zrdi5508v49pfm3iii2hn6nm00bgvfpjq1zxknfjrxxa20r4g"; })
+  (fetchNuGet { pname = "System.Runtime.Handles"; version = "4.3.0"; sha256 = "0sw2gfj2xr7sw9qjn0j3l9yw07x73lcs97p8xfc9w1x9h5g5m7i8"; })
+  (fetchNuGet { pname = "System.Runtime.InteropServices"; version = "4.1.0"; sha256 = "01kxqppx3dr3b6b286xafqilv4s2n0gqvfgzfd4z943ga9i81is1"; })
+  (fetchNuGet { pname = "System.Runtime.InteropServices"; version = "4.3.0"; sha256 = "00hywrn4g7hva1b2qri2s6rabzwgxnbpw9zfxmz28z09cpwwgh7j"; })
+  (fetchNuGet { pname = "System.Runtime.Numerics"; version = "4.0.1"; sha256 = "1y308zfvy0l5nrn46mqqr4wb4z1xk758pkk8svbz8b5ij7jnv4nn"; })
+  (fetchNuGet { pname = "System.Runtime.Numerics"; version = "4.3.0"; sha256 = "19rav39sr5dky7afygh309qamqqmi9kcwvz3i0c5700v0c5cg61z"; })
+  (fetchNuGet { pname = "System.Runtime.Serialization.Formatters"; version = "4.3.0"; sha256 = "114j35n8gcvn3sqv9ar36r1jjq0y1yws9r0yk8i6wm4aq7n9rs0m"; })
+  (fetchNuGet { pname = "System.Runtime.Serialization.Json"; version = "4.3.0"; sha256 = "1qp8ghr70smspnjdmlcbl5vwb7fm2iy1b7wx1p53lbpl35w4kz4a"; })
+  (fetchNuGet { pname = "System.Runtime.Serialization.Primitives"; version = "4.1.1"; sha256 = "042rfjixknlr6r10vx2pgf56yming8lkjikamg3g4v29ikk78h7k"; })
+  (fetchNuGet { pname = "System.Runtime.Serialization.Primitives"; version = "4.3.0"; sha256 = "01vv2p8h4hsz217xxs0rixvb7f2xzbh6wv1gzbfykcbfrza6dvnf"; })
+  (fetchNuGet { pname = "System.Security.AccessControl"; version = "4.5.0"; sha256 = "1wvwanz33fzzbnd2jalar0p0z3x0ba53vzx1kazlskp7pwyhlnq0"; })
+  (fetchNuGet { pname = "System.Security.Claims"; version = "4.0.1"; sha256 = "03dw0ls49bvsrffgwycyifjgz0qzr9r85skqhdyhfd51fqf398n6"; })
+  (fetchNuGet { pname = "System.Security.Claims"; version = "4.3.0"; sha256 = "0jvfn7j22l3mm28qjy3rcw287y9h65ha4m940waaxah07jnbzrhn"; })
+  (fetchNuGet { pname = "System.Security.Cryptography.Algorithms"; version = "4.2.0"; sha256 = "148s9g5dgm33ri7dnh19s4lgnlxbpwvrw2jnzllq2kijj4i4vs85"; })
+  (fetchNuGet { pname = "System.Security.Cryptography.Algorithms"; version = "4.3.0"; sha256 = "03sq183pfl5kp7gkvq77myv7kbpdnq3y0xj7vi4q1kaw54sny0ml"; })
+  (fetchNuGet { pname = "System.Security.Cryptography.Cng"; version = "4.2.0"; sha256 = "118jijz446kix20blxip0f0q8mhsh9bz118mwc2ch1p6g7facpzc"; })
+  (fetchNuGet { pname = "System.Security.Cryptography.Cng"; version = "4.3.0"; sha256 = "1k468aswafdgf56ab6yrn7649kfqx2wm9aslywjam1hdmk5yypmv"; })
+  (fetchNuGet { pname = "System.Security.Cryptography.Cng"; version = "4.5.0"; sha256 = "1pm4ykbcz48f1hdmwpia432ha6qbb9kbrxrrp7cg3m8q8xn52ngn"; })
+  (fetchNuGet { pname = "System.Security.Cryptography.Cng"; version = "5.0.0"; sha256 = "06hkx2za8jifpslkh491dfwzm5dxrsyxzj5lsc0achb6yzg4zqlw"; })
+  (fetchNuGet { pname = "System.Security.Cryptography.Csp"; version = "4.0.0"; sha256 = "1cwv8lqj8r15q81d2pz2jwzzbaji0l28xfrpw29kdpsaypm92z2q"; })
+  (fetchNuGet { pname = "System.Security.Cryptography.Csp"; version = "4.3.0"; sha256 = "1x5wcrddf2s3hb8j78cry7yalca4lb5vfnkrysagbn6r9x6xvrx1"; })
+  (fetchNuGet { pname = "System.Security.Cryptography.Encoding"; version = "4.0.0"; sha256 = "0a8y1a5wkmpawc787gfmnrnbzdgxmx1a14ax43jf3rj9gxmy3vk4"; })
+  (fetchNuGet { pname = "System.Security.Cryptography.Encoding"; version = "4.3.0"; sha256 = "1jr6w70igqn07k5zs1ph6xja97hxnb3mqbspdrff6cvssgrixs32"; })
+  (fetchNuGet { pname = "System.Security.Cryptography.OpenSsl"; version = "4.0.0"; sha256 = "16sx3cig3d0ilvzl8xxgffmxbiqx87zdi8fc73i3i7zjih1a7f4q"; })
+  (fetchNuGet { pname = "System.Security.Cryptography.OpenSsl"; version = "4.3.0"; sha256 = "0givpvvj8yc7gv4lhb6s1prq6p2c4147204a0wib89inqzd87gqc"; })
+  (fetchNuGet { pname = "System.Security.Cryptography.Pkcs"; version = "5.0.0"; sha256 = "0hb2mndac3xrw3786bsjxjfh19bwnr991qib54k6wsqjhjyyvbwj"; })
+  (fetchNuGet { pname = "System.Security.Cryptography.Primitives"; version = "4.0.0"; sha256 = "0i7cfnwph9a10bm26m538h5xcr8b36jscp9sy1zhgifksxz4yixh"; })
+  (fetchNuGet { pname = "System.Security.Cryptography.Primitives"; version = "4.3.0"; sha256 = "0pyzncsv48zwly3lw4f2dayqswcfvdwq2nz0dgwmi7fj3pn64wby"; })
+  (fetchNuGet { pname = "System.Security.Cryptography.ProtectedData"; version = "4.4.0"; sha256 = "1q8ljvqhasyynp94a1d7jknk946m20lkwy2c3wa8zw2pc517fbj6"; })
+  (fetchNuGet { pname = "System.Security.Cryptography.ProtectedData"; version = "4.5.0"; sha256 = "11qlc8q6b7xlspayv07718ibzvlj6ddqqxkvcbxv5b24d5kzbrb7"; })
+  (fetchNuGet { pname = "System.Security.Cryptography.X509Certificates"; version = "4.1.0"; sha256 = "0clg1bv55mfv5dq00m19cp634zx6inm31kf8ppbq1jgyjf2185dh"; })
+  (fetchNuGet { pname = "System.Security.Cryptography.X509Certificates"; version = "4.3.0"; sha256 = "0valjcz5wksbvijylxijjxb1mp38mdhv03r533vnx1q3ikzdav9h"; })
+  (fetchNuGet { pname = "System.Security.Permissions"; version = "4.5.0"; sha256 = "192ww5rm3c9mirxgl1nzyrwd18am3izqls0hzm0fvcdjl5grvbhm"; })
+  (fetchNuGet { pname = "System.Security.Principal"; version = "4.0.1"; sha256 = "1nbzdfqvzzbgsfdd5qsh94d7dbg2v4sw0yx6himyn52zf8z6007p"; })
+  (fetchNuGet { pname = "System.Security.Principal"; version = "4.3.0"; sha256 = "12cm2zws06z4lfc4dn31iqv7072zyi4m910d4r6wm8yx85arsfxf"; })
+  (fetchNuGet { pname = "System.Security.Principal.Windows"; version = "4.0.0"; sha256 = "1d3vc8i0zss9z8p4qprls4gbh7q4218l9845kclx7wvw41809k6z"; })
+  (fetchNuGet { pname = "System.Security.Principal.Windows"; version = "4.5.0"; sha256 = "0rmj89wsl5yzwh0kqjgx45vzf694v9p92r4x4q6yxldk1cv1hi86"; })
+  (fetchNuGet { pname = "System.Security.SecureString"; version = "4.0.0"; sha256 = "026q5f46585hgisz4svhnjc7q0ljprz43v15rybqizlyli5585jz"; })
+  (fetchNuGet { pname = "System.Security.SecureString"; version = "4.3.0"; sha256 = "1dypfbw7mxd8cbpcxs3jrp7i5wm1vnp43bv823mk2z94r36ixqfc"; })
+  (fetchNuGet { pname = "System.Text.Encoding"; version = "4.0.11"; sha256 = "1dyqv0hijg265dwxg6l7aiv74102d6xjiwplh2ar1ly6xfaa4iiw"; })
+  (fetchNuGet { pname = "System.Text.Encoding"; version = "4.3.0"; sha256 = "1f04lkir4iladpp51sdgmis9dj4y8v08cka0mbmsy0frc9a4gjqr"; })
+  (fetchNuGet { pname = "System.Text.Encoding.CodePages"; version = "4.5.0"; sha256 = "19x38911pawq4mrxrm04l2bnxwxxlzq8v8rj4cbxnfjj8pnd3vj3"; })
+  (fetchNuGet { pname = "System.Text.Encoding.CodePages"; version = "4.5.1"; sha256 = "1z21qyfs6sg76rp68qdx0c9iy57naan89pg7p6i3qpj8kyzn921w"; })
+  (fetchNuGet { pname = "System.Text.Encoding.Extensions"; version = "4.0.11"; sha256 = "08nsfrpiwsg9x5ml4xyl3zyvjfdi4mvbqf93kjdh11j4fwkznizs"; })
+  (fetchNuGet { pname = "System.Text.Encoding.Extensions"; version = "4.3.0"; sha256 = "11q1y8hh5hrp5a3kw25cb6l00v5l5dvirkz8jr3sq00h1xgcgrxy"; })
+  (fetchNuGet { pname = "System.Text.Encodings.Web"; version = "4.6.0"; sha256 = "0j61vkkcz390zbqsqqzdrzk4siqipi4359bgkh6icxli671k479l"; })
+  (fetchNuGet { pname = "System.Text.Encodings.Web"; version = "4.7.1"; sha256 = "1wj7r07mjwbf9a79kapy2l9m8mcq8b3nbhg0zaprlsav09k85fmb"; })
+  (fetchNuGet { pname = "System.Text.Json"; version = "4.6.0"; sha256 = "0ism236hwi0k6axssfq58s1d8lihplwiz058pdvl8al71hagri39"; })
+  (fetchNuGet { pname = "System.Text.Json"; version = "4.7.2"; sha256 = "10xj1pw2dgd42anikvj9qm23ccssrcp7dpznpj4j7xjp1ikhy3y4"; })
+  (fetchNuGet { pname = "System.Text.RegularExpressions"; version = "4.1.0"; sha256 = "1mw7vfkkyd04yn2fbhm38msk7dz2xwvib14ygjsb8dq2lcvr18y7"; })
+  (fetchNuGet { pname = "System.Text.RegularExpressions"; version = "4.3.0"; sha256 = "1bgq51k7fwld0njylfn7qc5fmwrk2137gdq7djqdsw347paa9c2l"; })
+  (fetchNuGet { pname = "System.Threading"; version = "4.0.11"; sha256 = "19x946h926bzvbsgj28csn46gak2crv2skpwsx80hbgazmkgb1ls"; })
+  (fetchNuGet { pname = "System.Threading"; version = "4.3.0"; sha256 = "0rw9wfamvhayp5zh3j7p1yfmx9b5khbf4q50d8k5rk993rskfd34"; })
+  (fetchNuGet { pname = "System.Threading.Overlapped"; version = "4.0.1"; sha256 = "0fi79az3vmqdp9mv3wh2phblfjls89zlj6p9nc3i9f6wmfarj188"; })
+  (fetchNuGet { pname = "System.Threading.Tasks"; version = "4.0.11"; sha256 = "0nr1r41rak82qfa5m0lhk9mp0k93bvfd7bbd9sdzwx9mb36g28p5"; })
+  (fetchNuGet { pname = "System.Threading.Tasks"; version = "4.3.0"; sha256 = "134z3v9abw3a6jsw17xl3f6hqjpak5l682k2vz39spj4kmydg6k7"; })
+  (fetchNuGet { pname = "System.Threading.Tasks.Extensions"; version = "4.0.0"; sha256 = "1cb51z062mvc2i8blpzmpn9d9mm4y307xrwi65di8ri18cz5r1zr"; })
+  (fetchNuGet { pname = "System.Threading.Tasks.Extensions"; version = "4.3.0"; sha256 = "1xxcx2xh8jin360yjwm4x4cf5y3a2bwpn2ygkfkwkicz7zk50s2z"; })
+  (fetchNuGet { pname = "System.Threading.Tasks.Extensions"; version = "4.5.2"; sha256 = "1sh63dz0dymqcwmprp0nadm77b83vmm7lyllpv578c397bslb8hj"; })
+  (fetchNuGet { pname = "System.Threading.Tasks.Extensions"; version = "4.5.3"; sha256 = "0g7r6hm572ax8v28axrdxz1gnsblg6kszq17g51pj14a5rn2af7i"; })
+  (fetchNuGet { pname = "System.Threading.Tasks.Extensions"; version = "4.5.4"; sha256 = "0y6ncasgfcgnjrhynaf0lwpkpkmv4a07sswwkwbwb5h7riisj153"; })
+  (fetchNuGet { pname = "System.Threading.Thread"; version = "4.0.0"; sha256 = "1gxxm5fl36pjjpnx1k688dcw8m9l7nmf802nxis6swdaw8k54jzc"; })
+  (fetchNuGet { pname = "System.Threading.ThreadPool"; version = "4.0.10"; sha256 = "0fdr61yjcxh5imvyf93n2m3n5g9pp54bnw2l1d2rdl9z6dd31ypx"; })
+  (fetchNuGet { pname = "System.Threading.ThreadPool"; version = "4.3.0"; sha256 = "027s1f4sbx0y1xqw2irqn6x161lzj8qwvnh2gn78ciiczdv10vf1"; })
+  (fetchNuGet { pname = "System.ValueTuple"; version = "4.5.0"; sha256 = "00k8ja51d0f9wrq4vv5z2jhq8hy31kac2rg0rv06prylcybzl8cy"; })
+  (fetchNuGet { pname = "System.Xml.ReaderWriter"; version = "4.0.11"; sha256 = "0c6ky1jk5ada9m94wcadih98l6k1fvf6vi7vhn1msjixaha419l5"; })
+  (fetchNuGet { pname = "System.Xml.ReaderWriter"; version = "4.3.0"; sha256 = "0c47yllxifzmh8gq6rq6l36zzvw4kjvlszkqa9wq3fr59n0hl3s1"; })
+  (fetchNuGet { pname = "System.Xml.XDocument"; version = "4.0.11"; sha256 = "0n4lvpqzy9kc7qy1a4acwwd7b7pnvygv895az5640idl2y9zbz18"; })
+  (fetchNuGet { pname = "System.Xml.XDocument"; version = "4.3.0"; sha256 = "08h8fm4l77n0nd4i4fk2386y809bfbwqb7ih9d7564ifcxr5ssxd"; })
+  (fetchNuGet { pname = "System.Xml.XmlDocument"; version = "4.3.0"; sha256 = "0bmz1l06dihx52jxjr22dyv5mxv6pj4852lx68grjm7bivhrbfwi"; })
+  (fetchNuGet { pname = "System.Xml.XmlSerializer"; version = "4.3.0"; sha256 = "07pa4sx196vxkgl3csvdmw94nydlsm9ir38xxcs84qjn8cycd912"; })
+]

pkgs/servers/web-apps/baget/updater.sh

···
+#!/usr/bin/env nix-shell
+#!nix-shell -i bash -p gnused jq common-updater-scripts nuget-to-nix dotnet-sdk_3 nix-prefetch-github
+set -eo pipefail
+cd "$(dirname "${BASH_SOURCE[0]}")"
+
+deps_file="$(realpath ./deps.nix)"
+
+new_version="$(curl -s "https://api.github.com/repos/loic-sharma/BaGet/releases?per_page=1" | jq -r '.[0].name' | sed 's,^v,,')"
+old_version="$(sed -nE 's/\s*version = "(.*)".*/\1/p' ./default.nix)"
+
+if [[ "$new_version" == "$old_version" ]]; then
+  echo "Already up to date!"
+  exit 0
+fi
+
+new_rev="v$new_version"
+nix-prefetch-github loic-sharma BaGet --rev "$new_rev" > repo_info
+new_hash="$(jq -r ".sha256" < repo_info)"
+rm repo_info
+
+pushd ../../../..
+
+update-source-version baget "$new_version" "$new_hash"
+store_src="$(nix-build -A baget.src --no-out-link)"
+src="$(mktemp -d /tmp/baget-src.XXX)"
+cp -rT "$store_src" "$src"
+
+trap 'rm -r "$src"' EXIT
+
+chmod -R +w "$src"
+
+pushd "$src"
+
+export DOTNET_NOLOGO=1
+export DOTNET_CLI_TELEMETRY_OPTOUT=1
+
+mkdir ./nuget_pkgs
+dotnet restore src/BaGet/BaGet.csproj --packages ./nuget_pkgs
+
+nuget-to-nix ./nuget_pkgs > "$deps_file"

pkgs/shells/zsh/default.nix

···
   checkFlags = map (T: "TESTNUM=${T}") (lib.stringToCharacters "ABCDEVW");
 
   # XXX: think/discuss about this, also with respect to nixos vs nix-on-X
-  postInstall = lib.optionalString stdenv.isDarwin ''
-    make install.bin install.modules install.fns
-    '' + lib.optionalString stdenv.isLinux ''
+  postInstall = lib.optionalString stdenv.isLinux ''
     make install.info install.html
     '' + ''
     mkdir -p $out/etc/

pkgs/tools/filesystems/lfs/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "lfs";
-  version = "1.3.1";
+  version = "1.4.0";
 
   src = fetchFromGitHub {
     owner = "Canop";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-3zGCVT3SfQm72CF2MasT7k5r1Jx9DRUrXKHBSpvcv10=";
+    sha256 = "sha256-mTgJ2DbSQprKKy7wTMXwmUAvHS9tacs9Nk1cmEJW9Sg=";
   };
 
-  cargoSha256 = "sha256-Q4eNvOY5c4KybDKVhcOznxGPUgyjgEYPD8+9r6sECXA=";
+  cargoSha256 = "sha256-Oiiz7I2eCtNMauvr0K2NtB49NJ/6XWVsJ0mMyEgFb7U=";
 
   meta = with lib; {
     description = "Get information on your mounted disks";

pkgs/tools/graphics/gifski/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "gifski";
-  version = "1.5.1";
+  version = "1.6.1";
 
   src = fetchFromGitHub {
     owner = "ImageOptim";
     repo = "gifski";
     rev = version;
-    sha256 = "sha256-x2p+6m1pwXhmI9JvGUgLhxrGwpJa/e2wb5wOFdKQ2xg=";
+    sha256 = "sha256-mM+gxBmMsdPUBOYyRdomd5+v+bqGN+udcuXI/stMZ4Y=";
   };
 
-  cargoSha256 = "sha256-8t7VhPby56UX2LlD2xcJKkWamuJxN9LiVEQPEa78EQQ=";
+  cargoSha256 = "sha256-5effx4tgMbnoVMO2Fza1naGFnMCvm0vhx6njo9/8bq0=";
 
   nativeBuildInputs = [ pkg-config ];
 

pkgs/tools/misc/code-minimap/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "code-minimap";
-  version = "0.6.2";
+  version = "0.6.4";
 
   src = fetchFromGitHub {
     owner = "wfxr";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-nUEmlKqCskPEQCOS2NC6jF4yVDarJeb3p+BKZq/2qvw=";
+    sha256 = "sha256-XhewfU3l/n2wiF9pKm1OOKQ7REzz3WzcBiVgOiYnAYU=";
   };
 
-  cargoSha256 = "sha256-yjjoQYYWK9/9fOP5ICnhpuF/07SyCszB9GCDr0GJ0v0=";
+  cargoSha256 = "sha256-Z3bc0w8slI9lHbDbrIK65xurtmTK4Y4caF7kxxJBA3Q=";
 
   buildInputs = lib.optional stdenv.isDarwin libiconv;
 

pkgs/tools/misc/dua/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "dua";
-  version = "2.14.11";
+  version = "2.16.0";
 
   buildInputs = lib.optionals stdenv.isDarwin [ libiconv Foundation ];
 
···
     owner = "Byron";
     repo = "dua-cli";
     rev = "v${version}";
-    sha256 = "sha256-XMhgTJiP4whw1r+WtdG5CsQl/GIZPEg7/ElIEMZyWqM=";
+    sha256 = "sha256-16qe5FKMC8cpGDR5HRVslYfG/OA8NSCuAbHpG7dfb3A=";
     # Remove unicode file names which leads to different checksums on HFS+
     # vs. other filesystems because of unicode normalisation.
     extraPostFetch = ''
···
     '';
   };
 
-  cargoSha256 = "sha256-B4e8wT/RhpwtCb11HqN8vksshBaF/CmpMPT62aBuFnw=";
+  cargoSha256 = "sha256-FX8fkG+Ecx9ZnbpX8UlLKYh4V6IJ98IbvBln0gCdD2M=";
 
   doCheck = false;
 

pkgs/tools/misc/kalker/default.nix

···
 }:
 rustPlatform.buildRustPackage rec {
   pname = "kalker";
-  version = "1.0.1-2";
+  version = "1.1.0";
 
   src = fetchFromGitHub {
     owner = "PaddiM8";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-fXTsCHqm+wO/ygyg0y+44G9pgaaEEH9fgePCDH86/vU=";
+    sha256 = "sha256-NnX4+VmV4oZg/8Z3ZCWHGZ6dqDfvH30XErnrvKMxyls=";
   };
 
-  cargoSha256 = "sha256-Ul21otEYCJuX5GnfV9OTpk/+3y32biASYZQpOecr8aU=";
+  cargoSha256 = "sha256-nSLbe3EhcLYylvyzOWuLIehBnD6mMofsNpFQVEybV8k=";
 
   buildInputs = [ gmp mpfr libmpc ];
 

pkgs/tools/networking/qodem/default.nix

···
+{ lib, stdenv, fetchFromGitHub, autoconf, automake, ncurses, SDL, gpm, miniupnpc }:
+
+stdenv.mkDerivation rec {
+  pname = "qodem";
+  version = "1.0.1";
+
+  src = fetchFromGitHub {
+    owner = "klamonte";
+    repo = "qodem";
+    rev = "v${version}";
+    sha256 = "NAdcTVmNrDa3rbsbxJxFoI7sz5NK5Uw+TbP+a1CdB+Q=";
+  };
+
+  nativeBuildInputs = [ autoconf automake ];
+  buildInputs = [ ncurses SDL gpm miniupnpc ];
+
+  meta = with lib; {
+    homepage = "http://qodem.sourceforge.net/";
+    description = "Re-implementation of the DOS-era Qmodem serial communications package";
+    longDescription = ''
+      Qodem is a from-scratch clone implementation of the Qmodem
+      communications program made popular in the days when Bulletin Board
+      Systems ruled the night. Qodem emulates the dialing directory and the
+      terminal screen features of Qmodem over both modem and Internet
+      connections.
+    '';
+    maintainers = with maintainers; [ embr ];
+    license = licenses.publicDomain;
+  };
+}

pkgs/tools/security/b3sum/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "b3sum";
-  version = "1.2.0";
+  version = "1.3.0";
 
   src = fetchCrate {
     inherit version pname;
-    sha256 = "sha256-v6OCUXes8jaBh+sKqj1yCNOTb1NQY/ENGzKf5XWGZ3w=";
+    sha256 = "sha256-mnX5ZetwOo0VMBIOqJEBpqnSX6EqBEO7qwfgtGclReQ=";
   };
 
-  cargoSha256 = "sha256-y5QVgu716p8TFoEeWIzX9aJWeT3FKwlh5vUQkKR6pdE=";
+  cargoSha256 = "sha256-SUoreAuWLxtBWmFdLDviDz16oVDB2ubTY3a3m+t8xx0=";
 
   meta = {
     description = "BLAKE3 cryptographic hash function";

pkgs/tools/security/exploitdb/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "exploitdb";
-  version = "2022-01-06";
+  version = "2022-01-11";
 
   src = fetchFromGitHub {
     owner = "offensive-security";
     repo = pname;
     rev = version;
-    sha256 = "sha256-SvzrUVuOzqcc4YzBYxuE8S0tFNb2Pr2FEj8KSpuKKGU=";
+    sha256 = "sha256-uvjn/n+w5Zv/RwvQmE7bl4PFXdN2OO6FrrEVKdGNsgo=";
   };
 
   nativeBuildInputs = [ makeWrapper ];

pkgs/tools/security/gomapenum/default.nix

···
 
 buildGoModule rec {
   pname = "gomapenum";
-  version = "1.0.0";
+  version = "1.0.2";
 
   src = fetchFromGitHub {
     owner = "nodauf";
     repo = "GoMapEnum";
     rev = "v${version}";
-    sha256 = "sha256-6WZTmRse3mj1bimHE81JdSc4VKpMFbcJN3U4zgHMzJc=";
+    sha256 = "sha256-6AwbG3rs3ZjCGpCDeesddXW63OOxsoWdRtueNx35K38=";
   };
 
   vendorSha256 = "sha256-Z/uLZIPKd75P9nI7kTFOwzWFkRTVwUojYEQms4OJ6Bk=";

pkgs/tools/security/grype/default.nix

···
 
 buildGoModule rec {
   pname = "grype";
-  version = "0.30.0";
+  version = "0.31.1";
 
   src = fetchFromGitHub {
     owner = "anchore";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-nUNjC1NNscqv+cirC/4/FlrbOomBXxnOoHvCVpBUOUs=";
+    sha256 = "sha256-3V8qBgRIogZNisUshhs9Va9cbZ5D2hBJwqXPvqSmEWw=";
   };
 
-  vendorSha256 = "sha256-XUj9Az/N/ZzCJF6a7EipPTntwlFYuVhg8JoS+GJES+w=";
+  vendorSha256 = "sha256-/Z0tRzd7v84h8TSfbT4EqwyHWpAb30VNr4EDrNlHyd4=";
 
   nativeBuildInputs = [ installShellFiles ];
 

pkgs/tools/security/httpx/default.nix

···
 
 buildGoModule rec {
   pname = "httpx";
-  version = "1.1.4";
+  version = "1.1.5";
 
   src = fetchFromGitHub {
     owner = "projectdiscovery";
     repo = "httpx";
     rev = "v${version}";
-    sha256 = "sha256-Mis3DQwcTazHVF7hkTRQ2OtQxeGut5LRUAloBXCdq3s=";
+    sha256 = "sha256-XA099gBp52g0RUbbFSE8uFa7gh56bO8H66KaFAtK1RU=";
   };
 
-  vendorSha256 = "sha256-53Mvc637J306MJLw+l1amAuZhUE/NdDvuWEe0fg4Hog=";
+  vendorSha256 = "sha256-rmuRZ8jRwSaAYgrOBgJwsEOAaUNJwhPJX9hEaJTX6/E=";
 
   meta = with lib; {
     description = "Fast and multi-purpose HTTP toolkit";

pkgs/tools/security/kubescape/default.nix

···
 
 buildGoModule rec {
   pname = "kubescape";
-  version = "1.0.138";
+  version = "1.0.139";
 
   src = fetchFromGitHub {
     owner = "armosec";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-/Rp4eNlvlONiH3F6Zv9GDUF26tmSuhFGUL1MoKOFSEc=";
+    sha256 = "sha256-CsIdr/+orDTGdEs4R069+PF3ZKuXx8uLxEsymFOLfOY=";
   };
 
   nativeBuildInputs = [

pkgs/tools/system/thermald/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "thermald";
-  version = "2.4.6";
+  version = "2.4.7";
 
   outputs = [ "out" "devdoc" ];
 
···
     owner = "intel";
     repo = "thermal_daemon";
     rev = "v${version}";
-    sha256 = "sha256-ZknZznoYVX3dNBIUvER6odv5eNrCV3//CXH1ypCf6tE=";
+    sha256 = "sha256-1vRIpX4qH9QbinzZr//u7D9CZ6cUHirhXwnUuQyCEdg=";
   };
 
   nativeBuildInputs = [

pkgs/top-level/all-packages.nix

···
 
   badvpn = callPackage ../tools/networking/badvpn {};
 
+  baget = callPackage ../servers/web-apps/baget { };
+
   barcode = callPackage ../tools/graphics/barcode {};
 
   bashmount = callPackage ../tools/filesystems/bashmount {};
···
 
   qmk = callPackage ../tools/misc/qmk { };
 
+  qodem = callPackage ../tools/networking/qodem { };
+
   qosmic = libsForQt5.callPackage ../applications/graphics/qosmic { };
 
   qownnotes = libsForQt514.callPackage ../applications/office/qownnotes { };
···
   itstool = callPackage ../development/tools/misc/itstool { };
 
   jam = callPackage ../development/tools/build-managers/jam { };
+
+  ftjam = callPackage ../development/tools/build-managers/jam/ftjam.nix { };
 
   javacc = callPackage ../development/tools/parsing/javacc {
     jdk = jdk8;
···
 
   ballerburg = callPackage ../games/ballerburg { } ;
 
+  blockattack = callPackage ../games/blockattack { } ;
+
   colobot = callPackage ../games/colobot {};
 
   doom-bcc = callPackage ../games/zdoom/bcc-git.nix { };
···
   taisei = callPackage ../games/taisei { };
 
   tcl2048 = callPackage ../games/tcl2048 { };
+
+  the-legend-of-edgar = callPackage ../games/the-legend-of-edgar { };
 
   the-powder-toy = callPackage ../games/the-powder-toy {
     lua = lua5_1;

pkgs/top-level/python-packages.nix

···
 
   jsonstreams = callPackage ../development/python-modules/jsonstreams { };
 
+  json-tricks = callPackage ../development/python-modules/json-tricks { };
+
   jug = callPackage ../development/python-modules/jug { };
 
   junitparser = callPackage ../development/python-modules/junitparser { };
···
 
   synologydsm-api = callPackage ../development/python-modules/synologydsm-api { };
 
+  syslog-rfc5424-formatter = callPackage ../development/python-modules/syslog-rfc5424-formatter { };
+
   systembridge = callPackage ../development/python-modules/systembridge { };
 
   systemd = callPackage ../development/python-modules/systemd {
···
   types-toml = callPackage ../development/python-modules/types-toml { };
 
   types-typed-ast = callPackage ../development/python-modules/types-typed-ast { };
+
+  types-urllib3 = callPackage ../development/python-modules/types-urllib3 { };
 
   typesentry = callPackage ../development/python-modules/typesentry { };