commit 615351069b0ada528edceef0bbf86394a02b30bb · pyrox.dev/nixpkgs

+1 -1

doc/languages-frameworks/python.section.md

···

       58
       58
        
       a re-usable environment in a single-file Python script; then we will create a

     

       59
       59
        
       full Python environment for development with this same environment.

     

       60
       60
        
       

     

       61
       61
       -
       Philosphically, this should be familiar to users who are used to a `venv` style

     

       61
       61
       +
       Philosophically, this should be familiar to users who are used to a `venv` style

     

       62
       62
        
       of development: individual projects create their own Python environments without

     

       63
       63
        
       impacting the global environment or each other.

     

       64
       64

+6

maintainers/maintainer-list.nix

···

       11511
       11511
        
           githubId = 3737;

     

       11512
       11512
        
           name = "Peter Jones";

     

       11513
       11513
        
         };

     

       11514
       11514
       +
         phip1611 = {

     

       11515
       11515
       +
           email = "phip1611@gmail.com";

     

       11516
       11516
       +
           github = "phip1611";

     

       11517
       11517
       +
           githubId = 5737016;

     

       11518
       11518
       +
           name = "Philipp Schuster";

     

       11519
       11519
       +
         };

     

       11514
       11520
        
         pkharvey = {

     

       11515
       11521
        
           email = "kayharvey@protonmail.com";

     

       11516
       11522
        
           github = "pkharvey";

+1

maintainers/scripts/eval-release.nix

···

       17
       17
        
               if (builtins.tryEval attrs.drvPath).success

     

       18
       18
        
               then { inherit (attrs) name drvPath; }

     

       19
       19
        
               else { failed = true; }

     

       20
       20
       +
             else if attrs == null then {}

     

       20
       21
        
             else { recurseForDerivations = true; } //

     

       21
       22
        
                  mapAttrs (n: v: let path' = path ++ [n]; in trace path' (recurse path' v)) attrs

     

       22
       23
        
           else { };

-3

nixos/modules/services/audio/hqplayerd.nix

···

       82
       82
        
             etc = {

     

       83
       83
        
               "hqplayer/hqplayerd.xml" = mkIf (cfg.config != null) { source = pkgs.writeText "hqplayerd.xml" cfg.config; };

     

       84
       84
        
               "hqplayer/hqplayerd4-key.xml" = mkIf (cfg.licenseFile != null) { source = cfg.licenseFile; };

     

       85
       85
       -
               "modules-load.d/taudio2.conf".source = "${pkg}/etc/modules-load.d/taudio2.conf";

     

       86
       85
        
             };

     

       87
       86
        
             systemPackages = [ pkg ];

     

       88
       87
        
           };

     
···

       90
       89
        
           networking.firewall = mkIf cfg.openFirewall {

     

       91
       90
        
             allowedTCPPorts = [ 8088 4321 ];

     

       92
       91
        
           };

     

       93
       93
       -
       

     

       94
       94
       -
           services.udev.packages = [ pkg ];

     

       95
       92
        
       

     

       96
       93
        
           systemd = {

     

       97
       94
        
             tmpfiles.rules = [

+1 -1

nixos/modules/services/hardware/throttled.nix

···

       20
       20
        
         config = mkIf cfg.enable {

     

       21
       21
        
           systemd.packages = [ pkgs.throttled ];

     

       22
       22
        
           # The upstream package has this in Install, but that's not enough, see the NixOS manual

     

       23
       23
       -
           systemd.services.lenovo_fix.wantedBy = [ "multi-user.target" ];

     

       23
       23
       +
           systemd.services.throttled.wantedBy = [ "multi-user.target" ];

     

       24
       24
        
       

     

       25
       25
        
           environment.etc."throttled.conf".source =

     

       26
       26
        
             if cfg.extraConfig != ""

+1

nixos/modules/services/monitoring/prometheus/exporters.nix

···

       64
       64
        
           "rspamd"

     

       65
       65
        
           "rtl_433"

     

       66
       66
        
           "script"

     

       67
       67
       +
           "shelly"

     

       67
       68
        
           "snmp"

     

       68
       69
        
           "smartctl"

     

       69
       70
        
           "smokeping"

+27

nixos/modules/services/monitoring/prometheus/exporters/shelly.nix

···

       1
       1
       +
       { config, lib, pkgs, options }:

     

       2
       2
       +
       

     

       3
       3
       +
       with lib;

     

       4
       4
       +
       

     

       5
       5
       +
       let

     

       6
       6
       +
         cfg = config.services.prometheus.exporters.shelly;

     

       7
       7
       +
       in

     

       8
       8
       +
       {

     

       9
       9
       +
         port = 9784;

     

       10
       10
       +
         extraOpts = {

     

       11
       11
       +
           metrics-file = mkOption {

     

       12
       12
       +
             type = types.path;

     

       13
       13
       +
             description = lib.mdDoc ''

     

       14
       14
       +
               Path to the JSON file with the metric definitions

     

       15
       15
       +
             '';

     

       16
       16
       +
           };

     

       17
       17
       +
         };

     

       18
       18
       +
         serviceOpts = {

     

       19
       19
       +
           serviceConfig = {

     

       20
       20
       +
             ExecStart = ''

     

       21
       21
       +
               ${pkgs.prometheus-shelly-exporter}/bin/shelly_exporter \

     

       22
       22
       +
                 -metrics-file ${cfg.metrics-file} \

     

       23
       23
       +
                 -listen-address ${cfg.listenAddress}:${toString cfg.port}

     

       24
       24
       +
             '';

     

       25
       25
       +
           };

     

       26
       26
       +
         };

     

       27
       27
       +
       }

+1

nixos/modules/services/networking/avahi-daemon.nix

···

       275
       275
        
               BusName = "org.freedesktop.Avahi";

     

       276
       276
        
               Type = "dbus";

     

       277
       277
        
               ExecStart = "${pkgs.avahi}/sbin/avahi-daemon --syslog -f ${avahiDaemonConf}";

     

       278
       278
       +
               ConfigurationDirectory = "avahi/services";

     

       278
       279
        
             };

     

       279
       280
        
           };

     

       280
       281

+2 -2

nixos/modules/virtualisation/amazon-options.nix

···

       28
       28
        
                   options = {

     

       29
       29
        
                     mount = lib.mkOption {

     

       30
       30
        
                       description = lib.mdDoc "Where to mount this dataset.";

     

       31
       31
       -
                       type = types.nullOr types.string;

     

       31
       31
       +
                       type = types.nullOr types.str;

     

       32
       32
        
                       default = null;

     

       33
       33
        
                     };

     

       34
       34
        
       

     

       35
       35
        
                     properties = lib.mkOption {

     

       36
       36
        
                       description = lib.mdDoc "Properties to set on this dataset.";

     

       37
       37
       -
                       type = types.attrsOf types.string;

     

       37
       37
       +
                       type = types.attrsOf types.str;

     

       38
       38
        
                       default = {};

     

       39
       39
        
                     };

     

       40
       40
        
                   };

+2 -2

nixos/modules/virtualisation/openstack-options.nix

···

       29
       29
        
                   options = {

     

       30
       30
        
                     mount = lib.mkOption {

     

       31
       31
        
                       description = lib.mdDoc "Where to mount this dataset.";

     

       32
       32
       -
                       type = types.nullOr types.string;

     

       32
       32
       +
                       type = types.nullOr types.str;

     

       33
       33
        
                       default = null;

     

       34
       34
        
                     };

     

       35
       35
        
       

     

       36
       36
        
                     properties = lib.mkOption {

     

       37
       37
        
                       description = lib.mdDoc "Properties to set on this dataset.";

     

       38
       38
       -
                       type = types.attrsOf types.string;

     

       38
       38
       +
                       type = types.attrsOf types.str;

     

       39
       39
        
                       default = { };

     

       40
       40
        
                     };

     

       41
       41
        
                   };

+3 -5

nixos/tests/apfs.nix

···

       21
       21
        
           with subtest("Enable case sensitivity and normalization sensitivity"):

     

       22
       22
        
             machine.succeed(

     

       23
       23
        
                 "mkapfs -s -z /dev/vdb",

     

       24
       24
       -
                 # Triggers a bug, see https://github.com/linux-apfs/linux-apfs-rw/issues/15

     

       25
       25
       -
                 # "mount -o cknodes,readwrite /dev/vdb /tmp/mnt",

     

       26
       26
       -
                 "mount -o readwrite /dev/vdb /tmp/mnt",

     

       24
       24
       +
                 "mount -o cknodes,readwrite /dev/vdb /tmp/mnt",

     

       27
       25
        
                 "echo 'Hello World 1' > /tmp/mnt/test.txt",

     

       28
       26
        
                 "[ ! -f /tmp/mnt/TeSt.TxT ] || false", # Test case sensitivity

     

       29
       27
        
                 "echo 'Hello World 1' | diff - /tmp/mnt/test.txt",

     
···

       36
       34
        
           with subtest("Disable case sensitivity and normalization sensitivity"):

     

       37
       35
        
             machine.succeed(

     

       38
       36
        
                 "mkapfs /dev/vdb",

     

       39
       39
       -
                 "mount -o readwrite /dev/vdb /tmp/mnt",

     

       37
       37
       +
                 "mount -o cknodes,readwrite /dev/vdb /tmp/mnt",

     

       40
       38
        
                 "echo 'bla bla bla' > /tmp/mnt/Test.txt",

     

       41
       39
        
                 "echo -n 'Hello World' > /tmp/mnt/test.txt",

     

       42
       40
        
                 "echo ' 1' >> /tmp/mnt/TEST.TXT",

     

       43
       41
        
                 "umount /tmp/mnt",

     

       44
       42
        
                 "apfsck /dev/vdb",

     

       45
       45
       -
                 "mount -o readwrite /dev/vdb /tmp/mnt",

     

       43
       43
       +
                 "mount -o cknodes,readwrite /dev/vdb /tmp/mnt",

     

       46
       44
        
                 "echo 'Hello World 1' | diff - /tmp/mnt/TeSt.TxT", # Test case insensitivity

     

       47
       45
        
                 "echo 'Hello World 2' > /tmp/mnt/\u0061\u0301.txt",

     

       48
       46
        
                 "echo 'Hello World 2' | diff - /tmp/mnt/\u0061\u0301.txt",

+14

nixos/tests/prometheus-exporters.nix

···

       1060
       1060
        
             '';

     

       1061
       1061
        
           };

     

       1062
       1062
        
       

     

       1063
       1063
       +
           shelly = {

     

       1064
       1064
       +
             exporterConfig = {

     

       1065
       1065
       +
               enable = true;

     

       1066
       1066
       +
               metrics-file = "${pkgs.writeText "test.json" ''{}''}";

     

       1067
       1067
       +
             };

     

       1068
       1068
       +
             exporterTest = ''

     

       1069
       1069
       +
               wait_for_unit("prometheus-shelly-exporter.service")

     

       1070
       1070
       +
               wait_for_open_port(9784)

     

       1071
       1071
       +
               wait_until_succeeds(

     

       1072
       1072
       +
                   "curl -sSf 'localhost:9784/metrics'"

     

       1073
       1073
       +
               )

     

       1074
       1074
       +
             '';

     

       1075
       1075
       +
           };

     

       1076
       1076
       +
       

     

       1063
       1077
        
           script = {

     

       1064
       1078
        
             exporterConfig = {

     

       1065
       1079
        
               enable = true;

+3 -3

pkgs/applications/audio/jmusicbot/default.nix

···

       1
       1
       -
       { stdenv, lib, fetchurl, makeWrapper, jre }:

     

       1
       1
       +
       { stdenv, lib, fetchurl, makeWrapper, jre_headless }:

     

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation rec {

     

       4
       4
        
         pname = "JMusicBot";

     
···

       17
       17
        
           mkdir -p $out/lib

     

       18
       18
        
           cp $src $out/lib/JMusicBot

     

       19
       19
        
       

     

       20
       20
       -
           makeWrapper ${jre}/bin/java $out/bin/JMusicBot \

     

       20
       20
       +
           makeWrapper ${jre_headless}/bin/java $out/bin/JMusicBot \

     

       21
       21
        
             --add-flags "-Xmx1G -Dnogui=true -Djava.util.concurrent.ForkJoinPool.common.parallelism=1 -jar $out/lib/JMusicBot"

     

       22
       22
        
         '';

     

       23
       23
        
       

     
···

       27
       27
        
           sourceProvenance = with sourceTypes; [ binaryBytecode ];

     

       28
       28
        
           license = licenses.asl20;

     

       29
       29
        
           maintainers = with maintainers; [ SuperSandro2000 ];

     

       30
       30
       -
           platforms = platforms.all;

     

       30
       30
       +
           inherit (jre_headless.meta) platforms;

     

       31
       31
        
         };

     

       32
       32
        
       }

+2 -2

pkgs/applications/audio/lsp-plugins/default.nix

···

       5
       5
        
       

     

       6
       6
        
       stdenv.mkDerivation rec {

     

       7
       7
        
               pname = "lsp-plugins";

     

       8
       8
       -
               version = "1.2.4";

     

       8
       8
       +
               version = "1.2.5";

     

       9
       9
        
       

     

       10
       10
        
               src = fetchurl {

     

       11
       11
        
                       url = "https://github.com/sadko4u/${pname}/releases/download/${version}/${pname}-src-${version}.tar.gz";

     

       12
       12
       -
                       sha256 = "sha256-GTrcUy10bN9Xj2I7uuGyP82c6NVpnQbXTI85H231yyo=";

     

       12
       12
       +
                       sha256 = "sha256-YYrt+FbpY7iEui0aw4Ce94BW1SHDk0OH8gFSzkW2fkw=";

     

       13
       13
        
               };

     

       14
       14
        
       

     

       15
       15
        
               nativeBuildInputs = [ pkg-config php makeWrapper ];

+2 -2

pkgs/applications/audio/musikcube/default.nix

···

       10
       10
        
       , gnutls

     

       11
       11
        
       , lame

     

       12
       12
        
       , libev

     

       13
       13
       -
       , libgme

     

       13
       13
       +
       , game-music-emu

     

       14
       14
        
       , libmicrohttpd

     

       15
       15
        
       , libopenmpt

     

       16
       16
        
       , mpg123

     
···

       51
       51
        
           gnutls

     

       52
       52
        
           lame

     

       53
       53
        
           libev

     

       54
       54
       -
           libgme

     

       54
       54
       +
           game-music-emu

     

       55
       55
        
           libmicrohttpd

     

       56
       56
        
           libopenmpt

     

       57
       57
        
           mpg123

+2 -2

pkgs/applications/audio/osdlyrics/default.nix

···

       17
       17
        
       

     

       18
       18
        
       stdenv.mkDerivation rec {

     

       19
       19
        
         pname = "osdlyrics";

     

       20
       20
       -
         version = "0.5.12";

     

       20
       20
       +
         version = "0.5.13";

     

       21
       21
        
       

     

       22
       22
        
         src = fetchFromGitHub {

     

       23
       23
        
           owner = "osdlyrics";

     

       24
       24
        
           repo = "osdlyrics";

     

       25
       25
        
           rev = version;

     

       26
       26
       -
           sha256 = "sha256-QGgwxmurdwo0xyq7p+1xditRebv64ewGTvNJI7MUnq4=";

     

       26
       26
       +
           sha256 = "sha256-E4pVXopqQYJW+a5nUf9dMabxJ9nYPu3C2ti8LlY470c=";

     

       27
       27
        
         };

     

       28
       28
        
       

     

       29
       29
        
         nativeBuildInputs = [

+38

pkgs/applications/audio/pianotrans/default.nix

···

       1
       1
       +
       { lib

     

       2
       2
       +
       , fetchFromGitHub

     

       3
       3
       +
       , python3

     

       4
       4
       +
       , ffmpeg

     

       5
       5
       +
       }:

     

       6
       6
       +
       

     

       7
       7
       +
       python3.pkgs.buildPythonApplication rec {

     

       8
       8
       +
         pname = "pianotrans";

     

       9
       9
       +
         version = "1.0";

     

       10
       10
       +
         format = "setuptools";

     

       11
       11
       +
       

     

       12
       12
       +
         src = fetchFromGitHub {

     

       13
       13
       +
           owner = "azuwis";

     

       14
       14
       +
           repo = pname;

     

       15
       15
       +
           rev = "v${version}";

     

       16
       16
       +
           hash = "sha256-6Otup1Yat1dBZdSoR4lDfpytUQ2RbDXC6ieo835Nw+U=";

     

       17
       17
       +
         };

     

       18
       18
       +
       

     

       19
       19
       +
         propagatedBuildInputs = with python3.pkgs; [

     

       20
       20
       +
           piano-transcription-inference

     

       21
       21
       +
           torch

     

       22
       22
       +
           tkinter

     

       23
       23
       +
         ];

     

       24
       24
       +
       

     

       25
       25
       +
         # Project has no tests

     

       26
       26
       +
         doCheck = false;

     

       27
       27
       +
       

     

       28
       28
       +
         makeWrapperArgs = [

     

       29
       29
       +
           ''--prefix PATH : "${lib.makeBinPath [ ffmpeg ]}"''

     

       30
       30
       +
         ];

     

       31
       31
       +
       

     

       32
       32
       +
         meta = with lib; {

     

       33
       33
       +
           description = "Simple GUI for ByteDance's Piano Transcription with Pedals";

     

       34
       34
       +
           homepage = "https://github.com/azuwis/pianotrans";

     

       35
       35
       +
           license = licenses.mit;

     

       36
       36
       +
           maintainers = with maintainers; [ azuwis ];

     

       37
       37
       +
         };

     

       38
       38
       +
       }

+6 -6

pkgs/applications/audio/yesplaymusic/default.nix

···

       22
       22
        
       , systemd

     

       23
       23
        
       }:

     

       24
       24
        
       let

     

       25
       25
       -
         pname = "YesPlayMusic";

     

       26
       26
       -
         version = "0.4.5";

     

       25
       25
       +
         pname = "yesplaymusic";

     

       26
       26
       +
         version = "0.4.7";

     

       27
       27
        
       

     

       28
       28
        
         srcs = {

     

       29
       29
        
           x86_64-linux = fetchurl {

     

       30
       30
        
             url = "https://github.com/qier222/YesPlayMusic/releases/download/v${version}/yesplaymusic_${version}_amd64.deb";

     

       31
       31
       -
             hash = "sha256-igd2MzIjwDSOLP0Xi2mSJnEPGWendggPC/MwTDCDui0=";

     

       31
       31
       +
             hash = "sha256-nnnHE2OgIqoz3dC+G0219FVBhvnWivLW1BX6+NYo6Ng=";

     

       32
       32
        
           };

     

       33
       33
        
           aarch64-linux = fetchurl {

     

       34
       34
        
             url = "https://github.com/qier222/YesPlayMusic/releases/download/v${version}/yesplaymusic_${version}_arm64.deb";

     

       35
       35
       -
             hash = "sha256-6MZrAJGXuEJ9HMUje3ppTz2rdaBydwoQKBk6af81pT0=";

     

       35
       35
       +
             hash = "sha256-+rrhY5iDDt/nYs0Vz5/Ef0sgpsdBKMtb1aVfCZLgRgg=";

     

       36
       36
        
           };

     

       37
       37
        
           x86_64-darwin = fetchurl {

     

       38
       38
        
             url = "https://github.com/qier222/YesPlayMusic/releases/download/v${version}/YesPlayMusic-mac-${version}-x64.dmg";

     

       39
       39
       -
             hash = "sha256-mvmaSrDoIDeOVylkJCVY97yRUHfEI8CysmKrgBUrFGM=";

     

       39
       39
       +
             hash = "sha256-z8CASZRWKlj1g3mhxTMMeR4klTvQ2ReSrL7Rt18qQbM=";

     

       40
       40
        
           };

     

       41
       41
        
           aarch64-darwin = fetchurl {

     

       42
       42
        
             url = "https://github.com/qier222/YesPlayMusic/releases/download/v${version}/YesPlayMusic-mac-${version}-arm64.dmg";

     

       43
       43
       -
             hash = "sha256-Qo03rGS/qB6Sc1IunU7F81WJ/t+mWR7ZRsKYK97LHik=";

     

       43
       43
       +
             hash = "sha256-McYLczudKG4tRNIw/Ws4rht0n4tiKA2M99yKtJbdlY8=";

     

       44
       44
        
           };

     

       45
       45
        
         };

     

       46
       46
        
         src = srcs.${stdenv.hostPlatform.system} or (throw "Unsupported system: ${stdenv.hostPlatform.system}");

+2 -1

pkgs/applications/blockchains/chia-dev-tools/default.nix

···

       37
       37
        
       

     

       38
       38
        
         propagatedBuildInputs = with python3Packages; [

     

       39
       39
        
           (toPythonModule chia)

     

       40
       40
       +
           pytest # required at runtime by the "test" command

     

       41
       41
       +
           pytest-asyncio

     

       40
       42
        
           pytimeparse

     

       41
       43
        
         ];

     

       42
       44
        
       

     

       43
       45
        
         nativeCheckInputs = with python3Packages; [

     

       44
       46
        
           pytestCheckHook

     

       45
       45
       -
           pytest-asyncio

     

       46
       47
        
         ];

     

       47
       48
        
       

     

       48
       49
        
         preCheck = ''

+3 -3

pkgs/applications/blockchains/erigon/default.nix

···

       2
       2
        
       

     

       3
       3
        
       let

     

       4
       4
        
         pname = "erigon";

     

       5
       5
       -
         version = "2.35.2";

     

       5
       5
       +
         version = "2.37.0";

     

       6
       6
        
       in

     

       7
       7
        
       buildGoModule {

     

       8
       8
        
         inherit pname version;

     
···

       11
       11
        
           owner = "ledgerwatch";

     

       12
       12
        
           repo = pname;

     

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

     

       14
       14
       -
           sha256 = "sha256-hGJ9SeUYACOuypTJmPnrv4f8ujjsUt3dZbwso+94g3M=";

     

       14
       14
       +
           sha256 = "sha256-r/mumt/f0wrOsXyEHo/NX0lJGt8zqXEVNC+9DWDkHAM=";

     

       15
       15
        
           fetchSubmodules = true;

     

       16
       16
        
         };

     

       17
       17
        
       

     

       18
       18
       -
         vendorSha256 = "sha256-lKzJLRCcyhQIV7y1XxqbvTINLlUwWFnflZgGQHYzBjY=";

     

       18
       18
       +
         vendorSha256 = "sha256-vSJZ1wIx1CiLE04ZBDnQDQqM2v8BBLxw5qbAsixC3/U=";

     

       19
       19
        
         proxyVendor = true;

     

       20
       20
        
       

     

       21
       21
        
         # Build errors in mdbx when format hardening is enabled:

+3 -3

pkgs/applications/editors/glow/default.nix

···

       2
       2
        
       

     

       3
       3
        
       buildGoModule rec {

     

       4
       4
        
         pname = "glow";

     

       5
       5
       -
         version = "1.4.1";

     

       5
       5
       +
         version = "1.5.0";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "charmbracelet";

     

       9
       9
        
           repo = "glow";

     

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

     

       11
       11
       -
           sha256 = "0m673xf67q9gjhd98ysh3dvwiqbj6lgsbm20c4zxyz76vdn5k6x8";

     

       11
       11
       +
           sha256 = "sha256-CI0S9XJtJQClpQvI6iSb5rcHafEUwr2V6+Fq560lRfM=";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
       -
         vendorSha256 = "0ngasfcimizahm80gflxzz3cxz0ir10l62i03l73w8syx4wll0q4";

     

       14
       14
       +
         vendorHash = "sha256-2QrHBbhJ04r/vPK2m8J2KZSFrREDCc18tlKd7evghBc=";

     

       15
       15
        
       

     

       16
       16
        
         doCheck = false;

     

       17
       17

+70 -65

pkgs/applications/emulators/ppsspp/default.nix

···

       12
       12
        
       , makeWrapper

     

       13
       13
        
       , pkg-config

     

       14
       14
        
       , python3

     

       15
       15
       -
       , qtbase ? null

     

       16
       16
       -
       , qtmultimedia ? null

     

       15
       15
       +
       , qtbase

     

       16
       16
       +
       , qtmultimedia

     

       17
       17
        
       , snappy

     

       18
       18
        
       , vulkan-loader

     

       19
       19
        
       , wayland

     

       20
       20
       -
       , wrapQtAppsHook ? null

     

       20
       20
       +
       , wrapQtAppsHook

     

       21
       21
        
       , zlib

     

       22
       22
       +
       , enableQt ? false

     

       22
       23
        
       , enableVulkan ? true

     

       23
       24
        
       , forceWayland ? false

     

       24
       25
        
       }:

     

       25
       26
        
       

     

       26
       27
        
       let

     

       27
       27
       -
         enableQt = (qtbase != null);

     

       28
       28
       -
         frontend = if enableQt then "Qt" else "SDL and headless";

     

       29
       29
       -
         vulkanPath = lib.makeLibraryPath [ vulkan-loader ];

     

       30
       30
       -
       

     

       31
       28
        
         # experimental, see https://github.com/hrydgard/ppsspp/issues/13845

     

       32
       29
        
         vulkanWayland = enableVulkan && forceWayland;

     

       33
       30
        
       in

     

       34
       34
       -
         # Only SDL front end needs to specify whether to use Wayland

     

       35
       35
       -
         assert forceWayland -> !enableQt;

     

       36
       36
       -
         stdenv.mkDerivation (finalAttrs: {

     

       37
       37
       -
           pname = "ppsspp"

     

       38
       38
       -
             + lib.optionalString enableQt "-qt"

     

       39
       39
       -
             + lib.optionalString (!enableQt) "-sdl"

     

       40
       40
       -
             + lib.optionalString forceWayland "-wayland";

     

       41
       41
       -
           version = "1.14.4";

     

       31
       31
       +
       # Only SDL frontend needs to specify whether to use Wayland

     

       32
       32
       +
       assert forceWayland -> !enableQt;

     

       33
       33
       +
       stdenv.mkDerivation (self: {

     

       34
       34
       +
         pname = "ppsspp"

     

       35
       35
       +
                 + lib.optionalString enableQt "-qt"

     

       36
       36
       +
                 + lib.optionalString (!enableQt) "-sdl"

     

       37
       37
       +
                 + lib.optionalString forceWayland "-wayland";

     

       38
       38
       +
         version = "1.14.4";

     

       42
       39
        
       

     

       43
       43
       -
           src = fetchFromGitHub {

     

       44
       44
       -
             owner = "hrydgard";

     

       45
       45
       -
             repo = "ppsspp";

     

       46
       46
       -
             rev = "v${finalAttrs.version}";

     

       47
       47
       -
             fetchSubmodules = true;

     

       48
       48
       -
             sha256 = "sha256-7xzhN8JIQD4LZg8sQ8rLNYZrW0nCNBfZFgzoKdoWbKc=";

     

       49
       49
       -
           };

     

       40
       40
       +
         src = fetchFromGitHub {

     

       41
       41
       +
           owner = "hrydgard";

     

       42
       42
       +
           repo = "ppsspp";

     

       43
       43
       +
           rev = "v${self.version}";

     

       44
       44
       +
           fetchSubmodules = true;

     

       45
       45
       +
           sha256 = "sha256-7xzhN8JIQD4LZg8sQ8rLNYZrW0nCNBfZFgzoKdoWbKc=";

     

       46
       46
       +
         };

     

       50
       47
        
       

     

       51
       51
       -
           postPatch = ''

     

       52
       52
       -
             substituteInPlace git-version.cmake --replace unknown ${finalAttrs.src.rev}

     

       53
       53
       -
             substituteInPlace UI/NativeApp.cpp --replace /usr/share $out/share

     

       54
       54
       -
           '';

     

       48
       48
       +
         postPatch = ''

     

       49
       49
       +
           substituteInPlace git-version.cmake --replace unknown ${self.src.rev}

     

       50
       50
       +
           substituteInPlace UI/NativeApp.cpp --replace /usr/share $out/share

     

       51
       51
       +
         '';

     

       55
       52
        
       

     

       56
       56
       -
           nativeBuildInputs = [

     

       57
       57
       -
             cmake

     

       58
       58
       -
             copyDesktopItems

     

       59
       59
       -
             makeWrapper

     

       60
       60
       -
             pkg-config

     

       61
       61
       -
             python3

     

       62
       62
       -
             wrapQtAppsHook

     

       63
       63
       -
           ];

     

       53
       53
       +
         nativeBuildInputs = [

     

       54
       54
       +
           cmake

     

       55
       55
       +
           copyDesktopItems

     

       56
       56
       +
           makeWrapper

     

       57
       57
       +
           pkg-config

     

       58
       58
       +
           python3

     

       59
       59
       +
         ] ++ lib.optional enableQt wrapQtAppsHook;

     

       64
       60
        
       

     

       65
       65
       -
           buildInputs = [

     

       66
       66
       -
             SDL2

     

       67
       67
       -
             ffmpeg

     

       68
       68
       -
             (glew.override { enableEGL = forceWayland; })

     

       69
       69
       -
             libzip

     

       70
       70
       -
             qtbase

     

       71
       71
       -
             qtmultimedia

     

       72
       72
       -
             snappy

     

       73
       73
       -
             zlib

     

       74
       74
       -
           ] ++ lib.optional enableVulkan vulkan-loader

     

       75
       75
       -
             ++ lib.optionals vulkanWayland [ wayland libffi ];

     

       61
       61
       +
         buildInputs = [

     

       62
       62
       +
           SDL2

     

       63
       63
       +
           ffmpeg

     

       64
       64
       +
           (glew.override { enableEGL = forceWayland; })

     

       65
       65
       +
           libzip

     

       66
       66
       +
           snappy

     

       67
       67
       +
           zlib

     

       68
       68
       +
         ] ++ lib.optionals enableQt [

     

       69
       69
       +
           qtbase

     

       70
       70
       +
           qtmultimedia

     

       71
       71
       +
         ] ++ lib.optional enableVulkan vulkan-loader

     

       72
       72
       +
         ++ lib.optionals vulkanWayland [ wayland libffi ];

     

       76
       73
        
       

     

       77
       77
       -
           cmakeFlags = [

     

       78
       78
       -
             "-DHEADLESS=${if enableQt then "OFF" else "ON"}"

     

       79
       79
       -
             "-DOpenGL_GL_PREFERENCE=GLVND"

     

       80
       80
       -
             "-DUSE_SYSTEM_FFMPEG=ON"

     

       81
       81
       -
             "-DUSE_SYSTEM_LIBZIP=ON"

     

       82
       82
       -
             "-DUSE_SYSTEM_SNAPPY=ON"

     

       83
       83
       -
             "-DUSE_WAYLAND_WSI=${if vulkanWayland then "ON" else "OFF"}"

     

       84
       84
       -
             "-DUSING_QT_UI=${if enableQt then "ON" else "OFF"}"

     

       85
       85
       -
           ];

     

       74
       74
       +
         cmakeFlags = [

     

       75
       75
       +
           "-DHEADLESS=${if enableQt then "OFF" else "ON"}"

     

       76
       76
       +
           "-DOpenGL_GL_PREFERENCE=GLVND"

     

       77
       77
       +
           "-DUSE_SYSTEM_FFMPEG=ON"

     

       78
       78
       +
           "-DUSE_SYSTEM_LIBZIP=ON"

     

       79
       79
       +
           "-DUSE_SYSTEM_SNAPPY=ON"

     

       80
       80
       +
           "-DUSE_WAYLAND_WSI=${if vulkanWayland then "ON" else "OFF"}"

     

       81
       81
       +
           "-DUSING_QT_UI=${if enableQt then "ON" else "OFF"}"

     

       82
       82
       +
         ];

     

       86
       83
        
       

     

       87
       87
       -
           desktopItems = [(makeDesktopItem {

     

       84
       84
       +
         desktopItems = [

     

       85
       85
       +
           (makeDesktopItem {

     

       88
       86
        
             desktopName = "PPSSPP";

     

       89
       87
        
             name = "ppsspp";

     

       90
       88
        
             exec = "ppsspp";

     

       91
       89
        
             icon = "ppsspp";

     

       92
       90
        
             comment = "Play PSP games on your computer";

     

       93
       91
        
             categories = [ "Game" "Emulator" ];

     

       94
       94
       -
           })];

     

       92
       92
       +
           })

     

       93
       93
       +
         ];

     

       95
       94
        
       

     

       96
       96
       -
           installPhase = ''

     

       95
       95
       +
         installPhase = let

     

       96
       96
       +
           vulkanPath = lib.makeLibraryPath [ vulkan-loader ];

     

       97
       97
       +
         in

     

       98
       98
       +
           ''

     

       97
       99
        
             runHook preInstall

     

       100
       100
       +
       

     

       98
       101
        
             mkdir -p $out/share/{applications,ppsspp}

     

       99
       102
        
           '' + (if enableQt then ''

     

       100
       103
        
             install -Dm555 PPSSPPQt $out/bin/ppsspp

     
···

       108
       111
        
               --prefix LD_LIBRARY_PATH : ${vulkanPath} \

     

       109
       112
        
           '' + "\n" + ''

     

       110
       113
        
             mv assets $out/share/ppsspp

     

       114
       114
       +
       

     

       111
       115
        
             runHook postInstall

     

       112
       116
        
           '';

     

       113
       117
        
       

     

       114
       114
       -
           meta = with lib; {

     

       115
       115
       -
             homepage = "https://www.ppsspp.org/";

     

       116
       116
       -
             description = "A HLE Playstation Portable emulator, written in C++ (${frontend})";

     

       117
       117
       -
             license = licenses.gpl2Plus;

     

       118
       118
       -
             maintainers = with maintainers; [ AndersonTorres ];

     

       119
       119
       -
             platforms = platforms.linux;

     

       120
       120
       -
           };

     

       121
       121
       -
         })

     

       118
       118
       +
         meta = {

     

       119
       119
       +
           homepage = "https://www.ppsspp.org/";

     

       120
       120
       +
           description = "A HLE Playstation Portable emulator, written in C++ ("

     

       121
       121
       +
                         + (if enableQt then "Qt" else "SDL + headless") + ")";

     

       122
       122
       +
           license = lib.licenses.gpl2Plus;

     

       123
       123
       +
           maintainers = [ lib.maintainers.AndersonTorres ];

     

       124
       124
       +
           platforms = lib.platforms.linux;

     

       125
       125
       +
         };

     

       126
       126
       +
       })

+15 -8

pkgs/applications/graphics/imv/default.nix

···

       11
       11
        
       , icu

     

       12
       12
        
       , pango

     

       13
       13
        
       , inih

     

       14
       14
       -
       , withWindowSystem ? "all"

     

       14
       14
       +
       , withWindowSystem ? null

     

       15
       15
        
       , xorg

     

       16
       16
        
       , libxkbcommon

     

       17
       17
        
       , libGLU

     
···

       27
       27
        
       }:

     

       28
       28
        
       

     

       29
       29
        
       let

     

       30
       30
       +
         # default value of withWindowSystem

     

       31
       31
       +
         withWindowSystem' =

     

       32
       32
       +
                if withWindowSystem != null then withWindowSystem

     

       33
       33
       +
           else if stdenv.isLinux then "all"

     

       34
       34
       +
           else "x11";

     

       35
       35
       +
       

     

       30
       36
        
         windowSystems = {

     

       31
       37
        
           all = windowSystems.x11 ++ windowSystems.wayland;

     

       32
       38
        
           x11 = [ libGLU xorg.libxcb xorg.libX11 ];

     
···

       47
       53
        
       in

     

       48
       54
        
       

     

       49
       55
        
       # check that given window system is valid

     

       50
       50
       -
       assert lib.assertOneOf "withWindowSystem" withWindowSystem

     

       56
       56
       +
       assert lib.assertOneOf "withWindowSystem" withWindowSystem'

     

       51
       57
        
         (builtins.attrNames windowSystems);

     

       52
       58
        
       # check that every given backend is valid

     

       53
       59
        
       assert builtins.all

     
···

       56
       62
        
       

     

       57
       63
        
       stdenv.mkDerivation rec {

     

       58
       64
        
         pname = "imv";

     

       59
       59
       -
         version = "4.3.1";

     

       65
       65
       +
         version = "4.4.0";

     

       60
       66
        
         outputs = [ "out" "man" ];

     

       61
       67
        
       

     

       62
       68
        
         src = fetchFromSourcehut {

     

       63
       69
        
           owner = "~exec64";

     

       64
       70
        
           repo = "imv";

     

       65
       71
        
           rev = "v${version}";

     

       66
       66
       -
           sha256 = "sha256-gMAd8skst72QT4jGFH7aRdWeAd4tf/uQgXhGaM/Dpgc=";

     

       72
       72
       +
           sha256 = "sha256-LLEEbriHzZhAOQivqHqdr6g7lh4uj++ytlme8AfRjf4=";

     

       67
       73
        
         };

     

       68
       74
        
       

     

       69
       75
        
         mesonFlags = [

     

       70
       70
       -
           "-Dwindows=${withWindowSystem}"

     

       76
       76
       +
           "-Dwindows=${withWindowSystem'}"

     

       71
       77
        
           "-Dtest=enabled"

     

       72
       78
        
           "-Dman=enabled"

     

       73
       79
        
         ] ++ backendFlags;

     
···

       87
       93
        
           libxkbcommon

     

       88
       94
        
           pango

     

       89
       95
        
           inih

     

       90
       90
       -
         ] ++ windowSystems."${withWindowSystem}"

     

       96
       96
       +
         ] ++ windowSystems."${withWindowSystem'}"

     

       91
       97
        
           ++ builtins.map (b: backends."${b}") withBackends;

     

       92
       98
        
       

     

       93
       99
        
         postInstall = ''

     
···

       96
       102
        
           install -Dm644 ../files/imv.desktop $out/share/applications/

     

       97
       103
        
         '';

     

       98
       104
        
       

     

       99
       99
       -
         postFixup = lib.optionalString (withWindowSystem == "all") ''

     

       105
       105
       +
         postFixup = lib.optionalString (withWindowSystem' == "all") ''

     

       100
       106
        
           # The `bin/imv` script assumes imv-wayland or imv-x11 in PATH,

     

       101
       107
        
           # so we have to fix those to the binaries we installed into the /nix/store

     

       102
       108
        
       

     
···

       109
       115
        
       

     

       110
       116
        
         meta = with lib; {

     

       111
       117
        
           description = "A command line image viewer for tiling window managers";

     

       112
       112
       -
           homepage = "https://github.com/eXeC64/imv";

     

       118
       118
       +
           homepage = "https://sr.ht/~exec64/imv/";

     

       113
       119
        
           license = licenses.mit;

     

       114
       120
        
           maintainers = with maintainers; [ rnhmjoj markus1189 ];

     

       115
       121
        
           platforms = platforms.all;

     

       122
       122
       +
           badPlatforms = platforms.darwin;

     

       116
       123
        
         };

     

       117
       124
        
       }

+2 -2

pkgs/applications/graphics/qiv/default.nix

···

       1
       1
        
       { lib, stdenv, fetchurl, pkg-config, gtk2, imlib2, file, lcms2, libexif } :

     

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation (rec {

     

       4
       4
       -
         version = "2.3.2";

     

       4
       4
       +
         version = "2.3.3";

     

       5
       5
        
         pname = "qiv";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchurl {

     

       8
       8
        
           url = "https://spiegl.de/qiv/download/${pname}-${version}.tgz";

     

       9
       9
       -
           sha256 = "1mc0f2nnas4q0d7zc9r6g4z93i32xlx0p9hl4fn5zkyml24a1q28";

     

       9
       9
       +
           sha256 = "sha256-7whf/eLUiwWzZlk55a4eNZ06OBAI+4J2hPfW/UxTNwQ=";

     

       10
       10
        
         };

     

       11
       11
        
       

     

       12
       12
        
         nativeBuildInputs = [ pkg-config ];

+11 -5

pkgs/applications/graphics/sane/xsane.nix

···

       1
       1
        
       { lib

     

       2
       2
        
       , stdenv

     

       3
       3
       -
       , fetchurl

     

       3
       3
       +
       , fetchFromGitLab

     

       4
       4
        
       , sane-backends

     

       5
       5
        
       , sane-frontends

     

       6
       6
        
       , libX11

     
···

       10
       10
        
       , libusb-compat-0_1

     

       11
       11
        
       , gimpSupport ? false

     

       12
       12
        
       , gimp

     

       13
       13
       +
       , nix-update-script

     

       13
       14
        
       }:

     

       14
       15
        
       

     

       15
       16
        
       stdenv.mkDerivation rec {

     

       16
       17
        
         pname = "xsane";

     

       17
       18
        
         version = "0.999";

     

       18
       19
        
       

     

       19
       19
       -
         src = fetchurl {

     

       20
       20
       -
           url = "http://www.xsane.org/download/xsane-${version}.tar.gz";

     

       21
       21
       -
           sha256 = "0jrb918sfb9jw3vmrz0z7np4q55hgsqqffpixs0ir5nwcwzd50jp";

     

       20
       20
       +
         src = fetchFromGitLab {

     

       21
       21
       +
           owner = "frontend";

     

       22
       22
       +
           group = "sane-project";

     

       23
       23
       +
           repo = pname;

     

       24
       24
       +
           rev = version;

     

       25
       25
       +
           hash = "sha256-oOg94nUsT9LLKnHocY0S5g02Y9a1UazzZAjpEI/s+yM=";

     

       22
       26
        
         };

     

       23
       27
        
       

     

       24
       28
        
         preConfigure = ''

     
···

       31
       35
        
         buildInputs = [ libpng libusb-compat-0_1 sane-backends sane-frontends libX11 gtk2 ]

     

       32
       36
        
           ++ lib.optional gimpSupport gimp;

     

       33
       37
        
       

     

       38
       38
       +
         passthru.updateScript = nix-update-script { };

     

       39
       39
       +
       

     

       34
       40
        
         meta = with lib; {

     

       35
       41
        
           homepage = "http://www.sane-project.org/";

     

       36
       42
        
           description = "Graphical scanning frontend for sane";

     

       37
       43
        
           license = licenses.gpl2Plus;

     

       38
       44
        
           platforms = platforms.linux;

     

       39
       39
       -
           maintainers = with maintainers; [ ];

     

       45
       45
       +
           maintainers = with maintainers; [ melling ];

     

       40
       46
        
         };

     

       41
       47
        
       }

+3 -3

pkgs/applications/misc/cotp/default.nix

···

       8
       8
        
       

     

       9
       9
        
       rustPlatform.buildRustPackage rec {

     

       10
       10
        
         name = "cotp";

     

       11
       11
       -
         version = "1.1.0";

     

       11
       11
       +
         version = "1.2.1";

     

       12
       12
        
       

     

       13
       13
        
         src = fetchFromGitHub {

     

       14
       14
        
           owner = "replydev";

     

       15
       15
        
           repo = "cotp";

     

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

     

       17
       17
       -
           hash = "sha256-SbS+ch7/45kZb49jW2mnRWQruLrfrNfeZFqEPHQKGUg=";

     

       17
       17
       +
           hash = "sha256-DIb/lgJxwg+QuqzN/0YoUV1iZwRqh6PAN0KRK7TbWDs=";

     

       18
       18
        
         };

     

       19
       19
        
       

     

       20
       20
       -
         cargoHash = "sha256-2lIR3K4/hr4XSmNGFd/dhwoFOtEB9KSnUrZkcaCyc9k=";

     

       20
       20
       +
         cargoHash = "sha256-uvH4mdI8ya/MJJngXQ98oXjG7JjUdvPwIzvJrdwlOEE=";

     

       21
       21
        
       

     

       22
       22
        
         buildInputs = lib.optionals stdenv.isLinux [ libxcb ]

     

       23
       23
        
           ++ lib.optionals stdenv.isDarwin [ AppKit ];

+2 -2

pkgs/applications/misc/gImageReader/default.nix

···

       16
       16
        
       in

     

       17
       17
        
       stdenv.mkDerivation rec {

     

       18
       18
        
         pname = "gImageReader";

     

       19
       19
       -
         version = "3.4.0";

     

       19
       19
       +
         version = "3.4.1";

     

       20
       20
        
       

     

       21
       21
        
         src = fetchFromGitHub {

     

       22
       22
        
           owner= "manisandro";

     

       23
       23
        
           repo = "gImageReader";

     

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

     

       25
       25
       -
           sha256 = "sha256-lJ4wPLxVN3NERnru8vLreiWMEUip6xeCXAfoT8DcfiQ=";

     

       25
       25
       +
           sha256 = "sha256-vW4FbviMHBiJ3rwJY/yS7JDOoCT72nGV6jEeo+k6ylU=";

     

       26
       26
        
         };

     

       27
       27
        
       

     

       28
       28
        
         nativeBuildInputs = [

+2 -2

pkgs/applications/misc/keystore-explorer/default.nix

···

       1
       1
        
       { fetchzip, lib, stdenv, jdk, runtimeShell, glib, wrapGAppsHook }:

     

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation rec {

     

       4
       4
       -
         version = "5.5.1";

     

       4
       4
       +
         version = "5.5.2";

     

       5
       5
        
         pname = "keystore-explorer";

     

       6
       6
        
         src = fetchzip {

     

       7
       7
        
           url = "https://github.com/kaikramer/keystore-explorer/releases/download/v${version}/kse-${lib.replaceStrings ["."] [""] version}.zip";

     

       8
       8
       -
           sha256 = "2C/LkUUuef30PkN7HL0CtcNOjR5uNo9XaCiTatv5hgA=";

     

       8
       8
       +
           sha256 = "sha256-mDi/TSYumCg2hAnMOI2QpdAOSlDMpdJPqzatFotAqUk=";

     

       9
       9
        
         };

     

       10
       10
        
       

     

       11
       11
        
         # glib is necessary so file dialogs don't hang.

+3 -3

pkgs/applications/misc/overmind/default.nix

···

       2
       2
        
       

     

       3
       3
        
       buildGoModule rec {

     

       4
       4
        
         pname = "overmind";

     

       5
       5
       -
         version = "2.3.0";

     

       5
       5
       +
         version = "2.4.0";

     

       6
       6
        
       

     

       7
       7
        
         nativeBuildInputs = [ makeWrapper ];

     

       8
       8
        
       

     
···

       14
       14
        
           owner = "DarthSim";

     

       15
       15
        
           repo = pname;

     

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

     

       17
       17
       -
           sha256 = "sha256-vmmSsg0JneMseFCcx/no2x/Ghppmyiod8ZAIb4JWW9I=";

     

       17
       17
       +
           sha256 = "sha256-cpsTytV1TbvdR7XUKkp4GPD1qyt1qnmY6qOsge01swE=";

     

       18
       18
        
         };

     

       19
       19
        
       

     

       20
       20
       -
         vendorSha256 = "sha256-QIKyLknPvmt8yiUCSCIqha8h9ozDGeQnKSM9Vwus0uY=";

     

       20
       20
       +
         vendorHash = "sha256-ndgnFBGtVFc++h+EnA37aY9+zNsO5GDrTECA4TEWPN4=";

     

       21
       21
        
       

     

       22
       22
        
         meta = with lib; {

     

       23
       23
        
           homepage = "https://github.com/DarthSim/overmind";

+8 -6

pkgs/applications/misc/pgmodeler/default.nix

···

       1
       1
        
       { lib

     

       2
       2
       +
       , stdenv

     

       2
       3
        
       , fetchFromGitHub

     

       4
       4
       +
       , wrapQtAppsHook

     

       3
       5
        
       , pkg-config

     

       4
       6
        
       , qmake

     

       5
       5
       -
       , mkDerivation

     

       7
       7
       +
       , qtwayland

     

       6
       8
        
       , qtsvg

     

       7
       9
        
       , postgresql

     

       8
       10
        
       }:

     

       9
       11
        
       

     

       10
       10
       -
       mkDerivation rec {

     

       12
       12
       +
       stdenv.mkDerivation rec {

     

       11
       13
        
         pname = "pgmodeler";

     

       12
       12
       -
         version = "1.0.0-beta1";

     

       14
       14
       +
         version = "1.0.0";

     

       13
       15
        
       

     

       14
       16
        
         src = fetchFromGitHub {

     

       15
       17
        
           owner = "pgmodeler";

     

       16
       18
        
           repo = "pgmodeler";

     

       17
       19
        
           rev = "v${version}";

     

       18
       18
       -
           sha256 = "sha256-5ZIzxo2UvE+aKznF9ZLYFg5z3JkYCB+9rGdVDJl14Hw=";

     

       20
       20
       +
           sha256 = "sha256-Lim9iQYdmulwZEIayoBGoAmQ7rysTEEof5iXy3kfKXs=";

     

       19
       21
        
         };

     

       20
       22
        
       

     

       21
       21
       -
         nativeBuildInputs = [ pkg-config qmake ];

     

       23
       23
       +
         nativeBuildInputs = [ pkg-config qmake wrapQtAppsHook ];

     

       22
       24
        
         qmakeFlags = [ "pgmodeler.pro" "CONFIG+=release" ];

     

       23
       25
        
       

     

       24
       26
        
         # todo: libpq would suffice here. Unfortunately this won't work, if one uses only postgresql.lib here.

     

       25
       25
       -
         buildInputs = [ postgresql qtsvg ];

     

       27
       27
       +
         buildInputs = [ postgresql qtsvg qtwayland ];

     

       26
       28
        
       

     

       27
       29
        
         meta = with lib; {

     

       28
       30
        
           description = "A database modeling tool for PostgreSQL";

+3 -3

pkgs/applications/networking/cluster/argocd-autopilot/default.nix

···

       2
       2
        
       

     

       3
       3
        
       buildGoModule rec {

     

       4
       4
        
         pname = "argocd-autopilot";

     

       5
       5
       -
         version = "0.4.10";

     

       5
       5
       +
         version = "0.4.11";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "argoproj-labs";

     

       9
       9
        
           repo = "argocd-autopilot";

     

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

     

       11
       11
       -
           sha256 = "sha256-DUWJDWqB+jyp3/2/eFP1ss2grNtrvUuvGWK0FYTXObc=";

     

       11
       11
       +
           sha256 = "sha256-0y7WP6v1DrAyK9p9cVME9RpNH1ZY0NNMtjHhmPT68kQ=";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
       -
         vendorHash = "sha256-4ylOLnpvz/aQIoxVz2z69Rq/x2UG91yMmtSHyquvNq0=";

     

       14
       14
       +
         vendorHash = "sha256-KkklEcxk6pNbxSkomh3LqlK8jgpGC/pZMBkJgXMUi8E=";

     

       15
       15
        
       

     

       16
       16
        
         proxyVendor = true;

     

       17
       17

+2 -2

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

···

       8
       8
        
       

     

       9
       9
        
       buildGoModule rec {

     

       10
       10
        
         pname = "kubeone";

     

       11
       11
       -
         version = "1.5.5";

     

       11
       11
       +
         version = "1.5.6";

     

       12
       12
        
       

     

       13
       13
        
         src = fetchFromGitHub {

     

       14
       14
        
           owner = "kubermatic";

     

       15
       15
        
           repo = "kubeone";

     

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

     

       17
       17
       -
           hash = "sha256-PdrU3kKuoT4MP5N2t4E1PIKZOMu8D0ZbUyMTIi/KZ7g=";

     

       17
       17
       +
           hash = "sha256-u0ievi2Zj5kerTQWhNPkT3HFdLYVwHOigkvWk6Zc3go=";

     

       18
       18
        
         };

     

       19
       19
        
       

     

       20
       20
        
         vendorHash = "sha256-Y4eivDchnN2rtQWjFY3cFiJXRfj48UfVUKM/OLuWXGA=";

+3 -3

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

···

       2
       2
        
       

     

       3
       3
        
       buildGoModule rec {

     

       4
       4
        
         pname = "tanka";

     

       5
       5
       -
         version = "0.23.1";

     

       5
       5
       +
         version = "0.24.0";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "grafana";

     

       9
       9
        
           repo = pname;

     

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

     

       11
       11
       -
           sha256 = "sha256-exPFlcbku51Bs/YISRyjl8iwLYRVS9ltRQPpd/QpnWk=";

     

       11
       11
       +
           sha256 = "sha256-RZLmbf9ginMbFAaUKL5mK5HIYQslP8Vu8zdh1OJ1P1Y=";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
       -
         vendorSha256 = "sha256-eo4B2p5Yo1r5jro49mSetp9AFYhcTXbyy7wGuaFwbb0=";

     

       14
       14
       +
         vendorHash = "sha256-g9e0NesI7WdaTHZ57XRlo8as3IWAFlFW4nkyf6+kd40=";

     

       15
       15
        
       

     

       16
       16
        
         doCheck = false;

     

       17
       17

+19 -19

pkgs/applications/networking/cluster/terraform-providers/providers.json

···

       84
       84
        
           "vendorHash": "sha256-99PwwxVHfRGC0QCQGhifRzqWFOHZ1R7Ge2ou7OjiggQ="

     

       85
       85
        
         },

     

       86
       86
        
         "auth0": {

     

       87
       87
       -
           "hash": "sha256-BlMYx6Ockk8YpiA0wCu2tBwhUIznFJ9b4knSeKA6M/g=",

     

       87
       87
       +
           "hash": "sha256-3iB/Vcv6Vzs9teulhu0npl6IuIJRsKy8FkBcIPTKw8A=",

     

       88
       88
        
           "homepage": "https://registry.terraform.io/providers/auth0/auth0",

     

       89
       89
        
           "owner": "auth0",

     

       90
       90
        
           "repo": "terraform-provider-auth0",

     

       91
       91
       -
           "rev": "v0.42.0",

     

       91
       91
       +
           "rev": "v0.43.0",

     

       92
       92
        
           "spdx": "MPL-2.0",

     

       93
       93
       -
           "vendorHash": "sha256-OhtomdRIjKxELnSQGbZvrHAE1ag4VAyuSOMrZvZ5q0s="

     

       93
       93
       +
           "vendorHash": "sha256-pRbhgukYRn0Ej0v/ANKZ3gtkmfL8qo1E6F/fKDNf/Iw="

     

       94
       94
        
         },

     

       95
       95
        
         "avi": {

     

       96
       96
        
           "hash": "sha256-0FcdVd7EGVHZ0iRonoGfjwYgXpJtUhqX5i925Ejhv54=",

     
···

       158
       158
        
           "vendorHash": "sha256-3PLBs8LSE5JPtrhmdx+jQsnCrfZQQEUGA7wnf9M72yY="

     

       159
       159
        
         },

     

       160
       160
        
         "bigip": {

     

       161
       161
       -
           "hash": "sha256-VntKiBTQxe8lKV8Bb3A0moA/EUzyQQ7CInPjKJL4iBQ=",

     

       161
       161
       +
           "hash": "sha256-nlk3ckrLNtPQ9s8uQ2jvARinPVF+A2T0IUY2rBcUFDk=",

     

       162
       162
        
           "homepage": "https://registry.terraform.io/providers/F5Networks/bigip",

     

       163
       163
        
           "owner": "F5Networks",

     

       164
       164
        
           "repo": "terraform-provider-bigip",

     

       165
       165
       -
           "rev": "v1.16.1",

     

       165
       165
       +
           "rev": "v1.16.2",

     

       166
       166
        
           "spdx": "MPL-2.0",

     

       167
       167
        
           "vendorHash": null

     

       168
       168
        
         },

     
···

       304
       304
        
           "vendorHash": "sha256-BpXhKjfxyCLdGRHn1GexW0MoLj4/C6Bn7scZ76JARxQ="

     

       305
       305
        
         },

     

       306
       306
        
         "digitalocean": {

     

       307
       307
       -
           "hash": "sha256-l/p2HStjvxF6UB1SnY3EoGjC/3t5FdlC6LMk7jn11KI=",

     

       307
       307
       +
           "hash": "sha256-ZTt/lfHWD9G/SbZ7mLKPjJAsva5bgRqvvX8Lh1Ci+ts=",

     

       308
       308
        
           "homepage": "https://registry.terraform.io/providers/digitalocean/digitalocean",

     

       309
       309
        
           "owner": "digitalocean",

     

       310
       310
        
           "repo": "terraform-provider-digitalocean",

     

       311
       311
       -
           "rev": "v2.25.2",

     

       311
       311
       +
           "rev": "v2.26.0",

     

       312
       312
        
           "spdx": "MPL-2.0",

     

       313
       313
        
           "vendorHash": null

     

       314
       314
        
         },

     
···

       368
       368
        
           "vendorHash": "sha256-NLvw606QxUwCDViLbR5LjoWGZnk48/zG0NownEATYKM="

     

       369
       369
        
         },

     

       370
       370
        
         "exoscale": {

     

       371
       371
       -
           "hash": "sha256-F1tYiEy9eQ7GcgVPNfe6Jy6hXEWdFHGXA6esAnOgiQE=",

     

       371
       371
       +
           "hash": "sha256-48msmXj7SFmi5TA0/QYm66oIETymWi5ayF+yExyp+hk=",

     

       372
       372
        
           "homepage": "https://registry.terraform.io/providers/exoscale/exoscale",

     

       373
       373
        
           "owner": "exoscale",

     

       374
       374
        
           "repo": "terraform-provider-exoscale",

     

       375
       375
       -
           "rev": "v0.43.0",

     

       375
       375
       +
           "rev": "v0.44.0",

     

       376
       376
        
           "spdx": "MPL-2.0",

     

       377
       377
        
           "vendorHash": null

     

       378
       378
        
         },

     
···

       1014
       1014
        
           "vendorHash": "sha256-MIO0VHofPtKPtynbvjvEukMNr5NXHgk7BqwIhbc9+u0="

     

       1015
       1015
        
         },

     

       1016
       1016
        
         "signalfx": {

     

       1017
       1017
       -
           "hash": "sha256-UgZr2ZFN5RvB7BG+DIXK6eSvTyvaVUKoBTIQ6aAfCpY=",

     

       1017
       1017
       +
           "hash": "sha256-9cGF/uyC/sqCx7Y9aEawkKVJvHE8siGgWRWWf4ok3B0=",

     

       1018
       1018
        
           "homepage": "https://registry.terraform.io/providers/splunk-terraform/signalfx",

     

       1019
       1019
        
           "owner": "splunk-terraform",

     

       1020
       1020
        
           "repo": "terraform-provider-signalfx",

     

       1021
       1021
       -
           "rev": "v6.21.0",

     

       1021
       1021
       +
           "rev": "v6.22.0",

     

       1022
       1022
        
           "spdx": "MPL-2.0",

     

       1023
       1023
        
           "vendorHash": "sha256-Iue8P14x8P0lMa85goSF1D5mEeXw6dH1atJQhgbnZ6Y="

     

       1024
       1024
        
         },

     
···

       1032
       1032
        
           "vendorHash": null

     

       1033
       1033
        
         },

     

       1034
       1034
        
         "snowflake": {

     

       1035
       1035
       -
           "hash": "sha256-0nofzwxzf19T9klfzp+h3icyN4S92nPfq/HN+qaHK/E=",

     

       1035
       1035
       +
           "hash": "sha256-cy/rolY0Ag/8Vbfs7XERIZxUsF65sap5/EHqU2w44bM=",

     

       1036
       1036
        
           "homepage": "https://registry.terraform.io/providers/Snowflake-Labs/snowflake",

     

       1037
       1037
        
           "owner": "Snowflake-Labs",

     

       1038
       1038
        
           "repo": "terraform-provider-snowflake",

     

       1039
       1039
       -
           "rev": "v0.56.0",

     

       1039
       1039
       +
           "rev": "v0.56.1",

     

       1040
       1040
        
           "spdx": "MIT",

     

       1041
       1041
        
           "vendorHash": "sha256-ulgTRY8qQ5oXONkwYtffRl1QMNnbvyn0zYiYqqvwrUU="

     

       1042
       1042
        
         },

     
···

       1104
       1104
        
           "vendorHash": null

     

       1105
       1105
        
         },

     

       1106
       1106
        
         "tfe": {

     

       1107
       1107
       -
           "hash": "sha256-YhsAKyD3YYYWfxIHcAgMxdQc//0WQvXTsa+fVhSCG6U=",

     

       1107
       1107
       +
           "hash": "sha256-eFyRa4T+CqIeOcEYj4DQP6ypR7AROYrGDYuYSqBfKr0=",

     

       1108
       1108
        
           "homepage": "https://registry.terraform.io/providers/hashicorp/tfe",

     

       1109
       1109
        
           "owner": "hashicorp",

     

       1110
       1110
        
           "repo": "terraform-provider-tfe",

     

       1111
       1111
       -
           "rev": "v0.41.0",

     

       1111
       1111
       +
           "rev": "v0.42.0",

     

       1112
       1112
        
           "spdx": "MPL-2.0",

     

       1113
       1113
       -
           "vendorHash": "sha256-LgCS7W6mGGlX4vEhlPYL+Wo/urHv7aiopXWEBoEyL1c="

     

       1113
       1113
       +
           "vendorHash": "sha256-bhAoNJSbrpAzw0qCKIm84h6tFqUWT0JeBs1gJpPeJdU="

     

       1114
       1114
        
         },

     

       1115
       1115
        
         "thunder": {

     

       1116
       1116
        
           "hash": "sha256-fXvwBOIW3/76V3O9t25wff0oGViqSaSB2VgMdItXyn4=",

     
···

       1250
       1250
        
           "vendorHash": "sha256-ib1Esx2AO7b9S+v+zzuATgSVHI3HVwbzEeyqhpBz1BQ="

     

       1251
       1251
        
         },

     

       1252
       1252
        
         "yandex": {

     

       1253
       1253
       -
           "hash": "sha256-g3BdCQKBuxrTn/sScJtRMyL2EoiOF5MpMXMM6I++dEg=",

     

       1253
       1253
       +
           "hash": "sha256-aBWcxC6mHM/3GOjnN/Qi0DNoZjehh5i3C2+XRZ2Igdo=",

     

       1254
       1254
        
           "homepage": "https://registry.terraform.io/providers/yandex-cloud/yandex",

     

       1255
       1255
        
           "owner": "yandex-cloud",

     

       1256
       1256
        
           "proxyVendor": true,

     

       1257
       1257
        
           "repo": "terraform-provider-yandex",

     

       1258
       1258
       -
           "rev": "v0.84.0",

     

       1258
       1258
       +
           "rev": "v0.85.0",

     

       1259
       1259
        
           "spdx": "MPL-2.0",

     

       1260
       1260
       -
           "vendorHash": "sha256-q9Rs2yJtI7MVqBcd9wwtyqR9PzmVkhKatbRRZwFm3po="

     

       1260
       1260
       +
           "vendorHash": "sha256-eLCFnBGAvH0ZEzOb5xVCY0Yy4U5V407AhpGSFpa9t7I="

     

       1261
       1261
        
         }

     

       1262
       1262
        
       }

+3 -3

pkgs/applications/networking/go-graft/default.nix

···

       2
       2
        
       

     

       3
       3
        
       buildGoModule rec {

     

       4
       4
        
         pname = "go-graft";

     

       5
       5
       -
         version = "0.2.15";

     

       5
       5
       +
         version = "0.2.16";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "mzz2017";

     

       9
       9
        
           repo = "gg";

     

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

     

       11
       11
       -
           sha256 = "sha256-INoJcb6XUMvT1E56hC3BGK3Ax+v4jSRpZV12zpjYfMA=";

     

       11
       11
       +
           sha256 = "sha256-zdOcQ/+WXS7pDfnvYdb/FDjMT3yJdwnS8DoH2MIDcDs=";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         CGO_ENABLED = 0;

     

       15
       15
        
       

     

       16
       16
        
         ldflags = [ "-X github.com/mzz2017/gg/cmd.Version=${version}" "-s" "-w" "-buildid=" ];

     

       17
       17
       -
         vendorSha256 = "sha256-kKIekANzLY2TYFyII1/BkKkqPYgmHB9xEfAVhJyI8FI=";

     

       17
       17
       +
         vendorHash = "sha256-kx94B1XIXWJOY9Y69lNb/sHWVjsuFuOXrdtJFJrUuAs=";

     

       18
       18
        
         subPackages = [ "." ];

     

       19
       19
        
       

     

       20
       20
        
         meta = with lib; {

+4 -4

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

···

       19
       19
        
       in

     

       20
       20
        
       stdenv.mkDerivation rec {

     

       21
       21
        
         pname = "briar-desktop";

     

       22
       22
       -
         version = "0.3.1-beta";

     

       22
       22
       +
         version = "0.4.0-beta";

     

       23
       23
        
       

     

       24
       24
        
         src = fetchurl {

     

       25
       25
       -
           url = "https://desktop.briarproject.org/jars/linux/0.3.1-beta/briar-desktop-linux-0.3.1-beta.jar";

     

       26
       26
       -
           sha256 = "841dc198101e6e8aa6b5ab6bd6b80e9c6b2593cb88bc3b2592f947baf963389d";

     

       25
       25
       +
           url = "https://desktop.briarproject.org/jars/linux/${version}/briar-desktop-linux-${version}.jar";

     

       26
       26
       +
           hash = "sha256-7zeIWsdPvROHGaf5igodlZss6Gow3kp6PX+QAzmxMnw=";

     

       27
       27
        
         };

     

       28
       28
        
       

     

       29
       29
        
         dontUnpack = true;

     
···

       58
       58
        
           homepage = "https://code.briarproject.org/briar/briar-desktop";

     

       59
       59
        
           license = licenses.gpl3;

     

       60
       60
        
           maintainers = with maintainers; [ onny ];

     

       61
       61
       -
           platforms = [ "x86_64-linux" "aarch64-linux" "armv7l-linux" ];

     

       61
       61
       +
           platforms = [ "x86_64-linux" ];

     

       62
       62
        
         };

     

       63
       63
        
       }

+3

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

···

       75
       75
        
       

     

       76
       76
        
         cmakeFlags = ["-DBUILD_TESTS=yes"];

     

       77
       77
        
       

     

       78
       78
       +
         # Undefined symbols for architecture arm64: "_gpg_strerror"

     

       79
       79
       +
         NIX_LDFLAGS = lib.optionalString stdenv.isDarwin "-lgpg-error";

     

       80
       80
       +
       

     

       78
       81
        
         doCheck = true;

     

       79
       82
        
         checkPhase = ''

     

       80
       83
        
           runHook preCheck

+5 -5

pkgs/applications/networking/instant-messengers/element/pin.json

···

       1
       1
        
       {

     

       2
       2
       -
         "version": "1.11.20",

     

       3
       3
       -
         "desktopSrcHash": "mlB2UvRYzaJ6FWGDOqyZY6NTY7QoWCiCvmFDyWTPuMQ=",

     

       4
       4
       -
         "desktopYarnHash": "0ccwsy9ma7sn6d5f9jfv40dhj0y6aax8msx9bihjdmx989nkkh2m",

     

       5
       5
       -
         "webSrcHash": "55oLS89Pmy4d7DhBQc4i6boQIH2LgujE7kl6QwcKltw=",

     

       6
       6
       -
         "webYarnHash": "1aiq5wvb8cz2a5rc0h11s16fnyak0p9zhzbqwhf1rs6c1gav7777"

     

       2
       2
       +
         "version": "1.11.22",

     

       3
       3
       +
         "desktopSrcHash": "UJesD6cshsf/NK2ZTzOtAUfH+8JcGP9oCLFhkgfM0E0=",

     

       4
       4
       +
         "desktopYarnHash": "0bq24rjf63rkq3jphv7raqaz2fnibmj41z905k5f3l4ln835ndfv",

     

       5
       5
       +
         "webSrcHash": "B2clSJgKkjvQdIXQgi3bBPaVTDKOjeNBOvkAtcPOkFI=",

     

       6
       6
       +
         "webYarnHash": "182fh1ayh1y98kbg4mn8fxqvljs19b02j4ivvjszm55dcpwfp1df"

     

       7
       7
        
       }

-3

pkgs/applications/networking/instant-messengers/element/update.sh

···

       1
       1
        
       #!/usr/bin/env nix-shell

     

       2
       2
        
       #!nix-shell -I nixpkgs=../../../../../ -i bash -p nix wget prefetch-yarn-deps nix-prefetch-github

     

       3
       3
        
       

     

       4
       4
       -
       # FIXME should fix itself on the next release -> remove the warning if that's the case

     

       5
       5
       -
       echo "WARNING: on the last update, the yarn.lock had to be patched. Please be careful when updating the hashes!"

     

       6
       6
       -
       

     

       7
       4
        
       if [ "$#" -gt 1 ] || [[ "$1" == -* ]]; then

     

       8
       5
        
         echo "Regenerates packaging data for the element packages."

     

       9
       6
        
         echo "Usage: $0 [git release tag]"

+2 -2

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

···

       2
       2
        
       

     

       3
       3
        
       let

     

       4
       4
        
         pname = "rambox";

     

       5
       5
       -
         version = "2.0.9";

     

       5
       5
       +
         version = "2.0.10";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchurl {

     

       8
       8
        
           url = "https://github.com/ramboxapp/download/releases/download/v${version}/Rambox-${version}-linux-x64.AppImage";

     

       9
       9
       -
           sha256 = "sha256-o2ydZodmMAYeU0IiczKNlzY2hgTJbzyJWO/cZSTfAuM=";

     

       9
       9
       +
           sha256 = "sha256-NvsrWkdINrQV7V9SLfjtlN+obgQb0u8d/QgjGpZ+fpc=";

     

       10
       10
        
         };

     

       11
       11
        
       

     

       12
       12
        
         desktopItem = (makeDesktopItem {

+3 -3

pkgs/applications/networking/nextdns/default.nix

···

       2
       2
        
       

     

       3
       3
        
       buildGoModule rec {

     

       4
       4
        
         pname = "nextdns";

     

       5
       5
       -
         version = "1.38.0";

     

       5
       5
       +
         version = "1.39.4";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "nextdns";

     

       9
       9
        
           repo = "nextdns";

     

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

     

       11
       11
       -
           sha256 = "sha256-dJ/3MBEsA8M4pfE+GPT/bNnK3n4fL3Hwk0umgMTJAfY=";

     

       11
       11
       +
           sha256 = "sha256-7inMloKU/AL4s/p171xCzs4p4+AcLsvsbVsELK9vhFc=";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
       -
         vendorSha256 = "sha256-pCta8FzGVpl9fvnnjQ7/e2x/HolXAuxnz0vwKejGk98=";

     

       14
       14
       +
         vendorHash = "sha256-pCta8FzGVpl9fvnnjQ7/e2x/HolXAuxnz0vwKejGk98=";

     

       15
       15
        
       

     

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

     

       17
       17

+2 -2

pkgs/applications/networking/rymdport/default.nix

···

       11
       11
        
       

     

       12
       12
        
       buildGoModule rec {

     

       13
       13
        
         pname = "rymdport";

     

       14
       14
       -
         version = "3.3.0";

     

       14
       14
       +
         version = "3.3.1";

     

       15
       15
        
       

     

       16
       16
        
         src = fetchFromGitHub {

     

       17
       17
        
           owner = "Jacalz";

     

       18
       18
        
           repo = "rymdport";

     

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

     

       20
       20
       -
           hash = "sha256-IsUKZL1aOKH01yZ7e/ciAESQKdZSscH+ytI3wptChy0=";

     

       20
       20
       +
           hash = "sha256-8Iul8YSxrfP7uG/uSmV+Qro+B1r+mhkOxCICHf204Lg=";

     

       21
       21
        
         };

     

       22
       22
        
       

     

       23
       23
        
         vendorHash = "sha256-9Z++E4Lb1+VBvOx5GJ4yQuj7fpwUhlsMhavTifKxVw4=";

+2 -2

pkgs/applications/office/gnumeric/default.nix

···

       7
       7
        
         inherit (python3Packages) python pygobject3;

     

       8
       8
        
       in stdenv.mkDerivation rec {

     

       9
       9
        
         pname = "gnumeric";

     

       10
       10
       -
         version = "1.12.53";

     

       10
       10
       +
         version = "1.12.54";

     

       11
       11
        
       

     

       12
       12
        
         src = fetchurl {

     

       13
       13
        
           url = "mirror://gnome/sources/${pname}/${lib.versions.majorMinor version}/${pname}-${version}.tar.xz";

     

       14
       14
       -
           sha256 = "VWjkyNzqu5Ao8TYdEEVSL5Xwpx2qWelzy90tObrdTwI=";

     

       14
       14
       +
           sha256 = "RpBAYv0cSkyTWW0mv2eTLNcvwPjSxaZ8F5GFJ/7oK3Q=";

     

       15
       15
        
         };

     

       16
       16
        
       

     

       17
       17
        
         configureFlags = [ "--disable-component" ];

+3 -6

pkgs/applications/office/morgen/default.nix

···

       3
       3
        
       

     

       4
       4
        
       stdenv.mkDerivation rec {

     

       5
       5
        
         pname = "morgen";

     

       6
       6
       -
         version = "2.5.16";

     

       6
       6
       +
         version = "2.6.4";

     

       7
       7
        
       

     

       8
       8
        
         src = fetchurl {

     

       9
       9
        
           url = "https://download.todesktop.com/210203cqcj00tw1/morgen-${version}.deb";

     

       10
       10
       -
           sha256 = "sha256-U77yOgQNSj1p3WZbwkyq0Ui2UrXeuAv5sD7L+ZI2x24=";

     

       10
       10
       +
           sha256 = "sha256-2Cze8R22Wrvp+FJq/7Kp36i7Areo5e9fdBo3DQ+rvZY=";

     

       11
       11
        
         };

     

       12
       12
        
       

     

       13
       13
        
         nativeBuildInputs = [

     
···

       19
       19
        
       

     

       20
       20
        
         buildInputs = [ alsa-lib gtk3 libxshmfence mesa nss ];

     

       21
       21
        
       

     

       22
       22
       -
         dontBuild = true;

     

       23
       23
       -
         dontConfigure = true;

     

       24
       24
       -
       

     

       25
       22
        
         unpackCmd = ''

     

       26
       23
        
           dpkg-deb -x ${src} ./morgen-${pname}

     

       27
       24
        
         '';

     
···

       37
       34
        
           # 2. Fixes startup script

     

       38
       35
        
           substituteInPlace $TMP/work/dist/main.js \

     

       39
       36
        
             --replace "process.resourcesPath,\"todesktop-runtime-config.json" "\"$out/opt/Morgen/resources/todesktop-runtime-config.json" \

     

       40
       40
       -
             --replace "Exec=\"+process.execPath+\"" "Exec=$out/bin/morgen"

     

       37
       37
       +
             --replace "Exec=\".concat(process.execPath," "Exec=\".concat(\"$out/bin/morgen\","

     

       41
       38
        
           asar pack --unpack='{*.node,*.ftz,rect-overlay}' "$TMP/work" $out/opt/Morgen/resources/app.asar

     

       42
       39
        
       

     

       43
       40
        
           substituteInPlace $out/share/applications/morgen.desktop \

+3 -3

pkgs/applications/radio/flex-ncat/default.nix

···

       2
       2
        
       

     

       3
       3
        
       buildGoModule rec {

     

       4
       4
        
         pname = "flex-ncat";

     

       5
       5
       -
         version = "0.1-20221109.1";

     

       5
       5
       +
         version = "0.2-20230126.0";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "kc2g-flex-tools";

     

       9
       9
        
           repo = "nCAT";

     

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

     

       11
       11
       -
           hash = "sha256-MlbzPZuEOhb3wJMXWkrt6DK8z0MPgznSm0N9Y6vJVWY=";

     

       11
       11
       +
           hash = "sha256-2taQQVTgAFyqtS06zZ+4Qmr/JIqU6mxNQYvxt+L/Mtc=";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
       -
         vendorSha256 = "sha256-lnJtFixgv4ke4Knavb+XKFPzHCiAPhNtfZS3SRVvY2g=";

     

       14
       14
       +
         vendorHash = "sha256-Tv6sbfWNOHYwA7v1SpNeM9aHs+3DSFv4V4qxllxrzJc=";

     

       15
       15
        
       

     

       16
       16
        
         meta = with lib; {

     

       17
       17
        
           homepage = "https://github.com/kc2g-flex-tools/nCAT";

+2 -2

pkgs/applications/science/robotics/betaflight-configurator/default.nix

···

       13
       13
        
       in

     

       14
       14
        
       stdenv.mkDerivation rec {

     

       15
       15
        
         inherit pname;

     

       16
       16
       -
         version = "10.8.0";

     

       16
       16
       +
         version = "10.9.0";

     

       17
       17
        
         src = fetchurl {

     

       18
       18
        
           url = "https://github.com/betaflight/${pname}/releases/download/${version}/${pname}_${version}_linux64-portable.zip";

     

       19
       19
       -
           sha256 = "sha256-Xn0ga2Z1UKd++TriL47ulV6idVTNBR8uiSW7FnL7r1g=";

     

       19
       19
       +
           sha256 = "sha256-9FzMyBIR2u1zXHtTWJABM6RF1+OyjYdEPlRwtig9blI=";

     

       20
       20
        
         };

     

       21
       21
        
       

     

       22
       22
        
         nativeBuildInputs = [ wrapGAppsHook unzip ];

+8 -13

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

···

       39
       39
        
       

     

       40
       40
        
         buildInputs = lib.optional pamSupport pam;

     

       41
       41
        
       

     

       42
       42
       -
         preBuild =

     

       43
       43
       -
           let

     

       44
       44
       -
             tags = lib.optional pamSupport "pam"

     

       45
       45
       -
               ++ lib.optional sqliteSupport "sqlite sqlite_unlock_notify";

     

       46
       46
       -
             tagsString = lib.concatStringsSep " " tags;

     

       47
       47
       -
           in

     

       48
       48
       -
           ''

     

       49
       49
       -
             export buildFlagsArray=(

     

       50
       50
       -
               -tags="${tagsString}"

     

       51
       51
       -
               -ldflags='-X "main.Version=${version}" -X "main.Tags=${tagsString}"'

     

       52
       52
       -
             )

     

       53
       53
       -
           '';

     

       42
       42
       +
         tags = lib.optional pamSupport "pam"

     

       43
       43
       +
           ++ lib.optionals sqliteSupport [ "sqlite" "sqlite_unlock_notify" ];

     

       54
       44
        
       

     

       55
       55
       -
         ldflags = [ "-s" "-w" ];

     

       45
       45
       +
         ldflags = [

     

       46
       46
       +
           "-s"

     

       47
       47
       +
           "-w"

     

       48
       48
       +
           "-X main.Version=${version}"

     

       49
       49
       +
           "-X 'main.Tags=${lib.concatStringsSep " " tags}'"

     

       50
       50
       +
         ];

     

       56
       51
        
       

     

       57
       52
        
         outputs = [ "out" "data" ];

     

       58
       53

+8 -8

pkgs/applications/version-management/gitlab/data.json

···

       1
       1
        
       {

     

       2
       2
       -
         "version": "15.7.5",

     

       3
       3
       -
         "repo_hash": "sha256-zo1b82y114NpX43rJAWQmUhORM1kQxyiSnonqPUQJmY=",

     

       4
       4
       -
         "yarn_hash": "086v3lr4hnz8z8pla1d3mi2smldidmx2z2cmffn830ianpqkk83l",

     

       2
       2
       +
         "version": "15.8.1",

     

       3
       3
       +
         "repo_hash": "sha256-AdgebB7IY18u/J1F67oNnwVYmmeYJPNCI/yll2eZEiQ=",

     

       4
       4
       +
         "yarn_hash": "1famdjvsbhvnkg5sp2vnc3jzaixww41833pb0427s3qpig0fc7az",

     

       5
       5
        
         "owner": "gitlab-org",

     

       6
       6
        
         "repo": "gitlab",

     

       7
       7
       -
         "rev": "v15.7.5-ee",

     

       7
       7
       +
         "rev": "v15.8.1-ee",

     

       8
       8
        
         "passthru": {

     

       9
       9
       -
           "GITALY_SERVER_VERSION": "15.7.5",

     

       10
       10
       -
           "GITLAB_PAGES_VERSION": "15.7.5",

     

       11
       11
       -
           "GITLAB_SHELL_VERSION": "14.14.0",

     

       12
       12
       -
           "GITLAB_WORKHORSE_VERSION": "15.7.5"

     

       9
       9
       +
           "GITALY_SERVER_VERSION": "15.8.1",

     

       10
       10
       +
           "GITLAB_PAGES_VERSION": "15.8.1",

     

       11
       11
       +
           "GITLAB_SHELL_VERSION": "14.15.0",

     

       12
       12
       +
           "GITLAB_WORKHORSE_VERSION": "15.8.1"

     

       13
       13
        
         }

     

       14
       14
        
       }

+5 -5

pkgs/applications/version-management/gitlab/gitaly/Gemfile.lock

···

       80
       80
        
             reverse_markdown (~> 1.0)

     

       81
       81
        
             rugged (>= 0.24, < 2.0)

     

       82
       82
        
             thor (>= 0.19, < 2.0)

     

       83
       83
       -
           loofah (2.19.0)

     

       83
       83
       +
           loofah (2.19.1)

     

       84
       84
        
             crass (~> 1.0.2)

     

       85
       85
        
             nokogiri (>= 1.5.9)

     

       86
       86
        
           memoizable (0.4.2)

     
···

       90
       90
        
           minitest (5.16.3)

     

       91
       91
        
           msgpack (1.3.3)

     

       92
       92
        
           multipart-post (2.1.1)

     

       93
       93
       -
           nokogiri (1.13.8)

     

       93
       93
       +
           nokogiri (1.13.10)

     

       94
       94
        
             mini_portile2 (~> 2.8.0)

     

       95
       95
        
             racc (~> 1.4)

     

       96
       96
        
           octokit (4.20.0)

     
···

       112
       112
        
             coderay (~> 1.1.0)

     

       113
       113
        
             method_source (~> 0.9.0)

     

       114
       114
        
           public_suffix (4.0.7)

     

       115
       115
       -
           racc (1.6.0)

     

       115
       115
       +
           racc (1.6.1)

     

       116
       116
        
           rack (2.2.4)

     

       117
       117
        
           rack-test (2.0.2)

     

       118
       118
        
             rack (>= 1.3)

     

       119
       119
        
           rails-dom-testing (2.0.3)

     

       120
       120
        
             activesupport (>= 4.2.0)

     

       121
       121
        
             nokogiri (>= 1.6)

     

       122
       122
       -
           rails-html-sanitizer (1.4.3)

     

       123
       123
       -
             loofah (~> 2.3)

     

       122
       122
       +
           rails-html-sanitizer (1.4.4)

     

       123
       123
       +
             loofah (~> 2.19, >= 2.19.1)

     

       124
       124
        
           rainbow (3.0.0)

     

       125
       125
        
           rbtrace (0.4.14)

     

       126
       126
        
             ffi (>= 1.0.6)

+3 -3

pkgs/applications/version-management/gitlab/gitaly/default.nix

···

       11
       11
        
           gemdir = ./.;

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
       -
         version = "15.7.5";

     

       14
       14
       +
         version = "15.8.1";

     

       15
       15
        
         package_version = "v${lib.versions.major version}";

     

       16
       16
        
         gitaly_package = "gitlab.com/gitlab-org/gitaly/${package_version}";

     

       17
       17
        
       

     
···

       22
       22
        
             owner = "gitlab-org";

     

       23
       23
        
             repo = "gitaly";

     

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

     

       25
       25
       -
             sha256 = "sha256-FT77MUcErc/16tChwyNczCLtADTOEzKKTsTlhLI6aV8=";

     

       25
       25
       +
             sha256 = "sha256-TolduUm8OhpubHXMCyy0vQhj65lauh5eST5UDvdWNVE=";

     

       26
       26
        
           };

     

       27
       27
        
       

     

       28
       28
       -
           vendorSha256 = "sha256-UEEM0mv7d0gmDcsSKbeh4JcTnX4f5oogZnhRpqaNxwY=";

     

       28
       28
       +
           vendorSha256 = "sha256-8P5X/bqeI1hY45IGsvEWOg3GuetEQF/XtZzUMdX22pA=";

     

       29
       29
        
       

     

       30
       30
        
           ldflags = [ "-X ${gitaly_package}/internal/version.version=${version}" "-X ${gitaly_package}/internal/version.moduleVersion=${version}" ];

     

       31
       31

+8 -8

pkgs/applications/version-management/gitlab/gitaly/gemset.nix

···

       317
       317
        
           platforms = [];

     

       318
       318
        
           source = {

     

       319
       319
        
             remotes = ["https://rubygems.org"];

     

       320
       320
       -
             sha256 = "1fpyk1965py77al7iadkn5dibwgvybknkr7r8bii2dj73wvr29rh";

     

       320
       320
       +
             sha256 = "08qhzck271anrx9y6qa6mh8hwwdzsgwld8q0000rcd7yvvpnjr3c";

     

       321
       321
        
             type = "gem";

     

       322
       322
        
           };

     

       323
       323
       -
           version = "2.19.0";

     

       323
       323
       +
           version = "2.19.1";

     

       324
       324
        
         };

     

       325
       325
        
         memoizable = {

     

       326
       326
        
           dependencies = ["thread_safe"];

     
···

       385
       385
        
           platforms = [];

     

       386
       386
        
           source = {

     

       387
       387
        
             remotes = ["https://rubygems.org"];

     

       388
       388
       -
             sha256 = "0g7axlq2y6gzmixzzzhw3fn6nhrhg469jj8gfr7gs8igiclpkhkr";

     

       388
       388
       +
             sha256 = "0n79k78c5vdcyl0m3y3l5x9kxl6xf5lgriwi2vd665qmdkr01vnk";

     

       389
       389
        
             type = "gem";

     

       390
       390
        
           };

     

       391
       391
       -
           version = "1.13.8";

     

       391
       391
       +
           version = "1.13.10";

     

       392
       392
        
         };

     

       393
       393
        
         octokit = {

     

       394
       394
        
           dependencies = ["faraday" "sawyer"];

     
···

       494
       494
        
           platforms = [];

     

       495
       495
        
           source = {

     

       496
       496
        
             remotes = ["https://rubygems.org"];

     

       497
       497
       -
             sha256 = "0la56m0z26j3mfn1a9lf2l03qx1xifanndf9p3vx1azf6sqy7v9d";

     

       497
       497
       +
             sha256 = "0p685i23lr8pl7l09g9l2mcj615fr7g33w3mkcr472lcg34nq8n8";

     

       498
       498
        
             type = "gem";

     

       499
       499
        
           };

     

       500
       500
       -
           version = "1.6.0";

     

       500
       500
       +
           version = "1.6.1";

     

       501
       501
        
         };

     

       502
       502
        
         rack = {

     

       503
       503
        
           groups = ["default"];

     
···

       537
       537
        
           platforms = [];

     

       538
       538
        
           source = {

     

       539
       539
        
             remotes = ["https://rubygems.org"];

     

       540
       540
       -
             sha256 = "1mj0b7ay10a2fgwj70kjw7mlyrp7a5la8lx8zmwhy40bkansdfrf";

     

       540
       540
       +
             sha256 = "1mcb75qvldfz6zsr4inrfx7dmb0ngxy507awx28khqmnla3hqpc9";

     

       541
       541
        
             type = "gem";

     

       542
       542
        
           };

     

       543
       543
       -
           version = "1.4.3";

     

       543
       543
       +
           version = "1.4.4";

     

       544
       544
        
         };

     

       545
       545
        
         rainbow = {

     

       546
       546
        
           source = {

+3 -3

pkgs/applications/version-management/gitlab/gitlab-shell/default.nix

···

       2
       2
        
       

     

       3
       3
        
       buildGoModule rec {

     

       4
       4
        
         pname = "gitlab-shell";

     

       5
       5
       -
         version = "14.14.0";

     

       5
       5
       +
         version = "14.15.0";

     

       6
       6
        
         src = fetchFromGitLab {

     

       7
       7
        
           owner = "gitlab-org";

     

       8
       8
        
           repo = "gitlab-shell";

     

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

     

       10
       10
       -
           sha256 = "sha256-zXRLaEy2Q+mm1GLjLB1AxRtBxXAoLw6PA1YOJfvVhoc=";

     

       10
       10
       +
           sha256 = "sha256-GDhYBL5LT3r6UIjDDY3LV5VgcBch190hYLPb6uMWETs=";

     

       11
       11
        
         };

     

       12
       12
        
       

     

       13
       13
        
         buildInputs = [ ruby ];

     

       14
       14
        
       

     

       15
       15
        
         patches = [ ./remove-hardcoded-locations.patch ];

     

       16
       16
        
       

     

       17
       17
       -
         vendorSha256 = "sha256-mhmM33cXJbqVJ1jY82Mi/nWzz7HXdxxSsFNQknFkwpQ=";

     

       17
       17
       +
         vendorSha256 = "sha256-2DpQNJw67ipIW3ctHDJthuDrKNZCYvjXGlDxzBEMGWs=";

     

       18
       18
        
       

     

       19
       19
        
         postInstall = ''

     

       20
       20
        
           cp -r "$NIX_BUILD_TOP/source"/bin/* $out/bin

+2 -2

pkgs/applications/version-management/gitlab/gitlab-workhorse/default.nix

···

       5
       5
        
       buildGoModule rec {

     

       6
       6
        
         pname = "gitlab-workhorse";

     

       7
       7
        
       

     

       8
       8
       -
         version = "15.7.5";

     

       8
       8
       +
         version = "15.8.1";

     

       9
       9
        
       

     

       10
       10
        
         src = fetchFromGitLab {

     

       11
       11
        
           owner = data.owner;

     
···

       16
       16
        
       

     

       17
       17
        
         sourceRoot = "source/workhorse";

     

       18
       18
        
       

     

       19
       19
       -
         vendorSha256 = "sha256-TrLc5L4kLAdu1CEM3ezw6hhF6Icy3rXkFyUaVTUQ6X4=";

     

       19
       19
       +
         vendorSha256 = "sha256-0FWR6cIV/0R2OrOAKhvuVnIY3Hkw4CIjyBUeF/paumw=";

     

       20
       20
        
         buildInputs = [ git ];

     

       21
       21
        
         ldflags = [ "-X main.Version=${version}" ];

     

       22
       22
        
         doCheck = false;

+11 -10

pkgs/applications/version-management/gitlab/rubyEnv/Gemfile

···

       5
       5
        
       if ENV['BUNDLER_CHECKSUM_VERIFICATION_OPT_IN'] # this verification is still experimental

     

       6
       6
        
         $LOAD_PATH.unshift(File.expand_path("vendor/gems/bundler-checksum/lib", __dir__))

     

       7
       7
        
         require 'bundler-checksum'

     

       8
       8
       -
         Bundler::Checksum.patch!

     

       8
       8
       +
         BundlerChecksum.patch!

     

       9
       9
        
       end

     

       10
       10
        
       

     

       11
       11
        
       gem 'bundler-checksum', '~> 0.1.0', path: 'vendor/gems/bundler-checksum', require: false

     
···

       37
       37
        
       gem 'default_value_for', '~> 3.4.0'

     

       38
       38
        
       

     

       39
       39
        
       # Supported DBs

     

       40
       40
       -
       gem 'pg', '~> 1.4.3'

     

       40
       40
       +
       gem 'pg', '~> 1.4.5'

     

       41
       41
        
       

     

       42
       42
        
       gem 'rugged', '~> 1.2'

     

       43
       43
        
       gem 'grape-path-helpers', '~> 1.7.1'

     
···

       84
       84
        
       gem 'timfel-krb5-auth', '~> 0.8', group: :kerberos

     

       85
       85
        
       

     

       86
       86
        
       # Spam and anti-bot protection

     

       87
       87
       -
       gem 'recaptcha', '~> 4.11', require: 'recaptcha/rails'

     

       87
       87
       +
       gem 'recaptcha', '~> 5.12', require: 'recaptcha/rails'

     

       88
       88
        
       gem 'akismet', '~> 3.0'

     

       89
       89
        
       gem 'invisible_captcha', '~> 2.0.0'

     

       90
       90
        
       

     
···

       113
       113
        
       # GitLab fork with several improvements to original library. For full list of changes

     

       114
       114
        
       # see https://github.com/intridea/omniauth-ldap/compare/master...gitlabhq:master

     

       115
       115
        
       gem 'gitlab_omniauth-ldap', '~> 2.2.0', require: 'omniauth-ldap'

     

       116
       116
       -
       gem 'net-ldap', '~> 0.16.3'

     

       116
       116
       +
       gem 'net-ldap', '~> 0.17.1'

     

       117
       117
        
       

     

       118
       118
        
       # API

     

       119
       119
        
       gem 'grape', '~> 1.5.2'

     
···

       200
       200
        
       gem 'diff_match_patch', '~> 0.1.0'

     

       201
       201
        
       

     

       202
       202
        
       # Application server

     

       203
       203
       -
       gem 'rack', '~> 2.2.4'

     

       203
       203
       +
       gem 'rack', '~> 2.2.6', '>= 2.2.6.2'

     

       204
       204
        
       # https://github.com/zombocom/rack-timeout/blob/master/README.md#rails-apps-manually

     

       205
       205
        
       gem 'rack-timeout', '~> 0.6.3', require: 'rack/timeout/base'

     

       206
       206
        
       

     
···

       304
       304
        
       gem 'gitlab-chronic', '~> 0.10.5'

     

       305
       305
        
       gem 'gitlab_chronic_duration', '~> 0.10.6.2'

     

       306
       306
        
       

     

       307
       307
       -
       gem 'rack-proxy', '~> 0.7.4'

     

       307
       307
       +
       gem 'rack-proxy', '~> 0.7.6'

     

       308
       308
        
       

     

       309
       309
        
       gem 'sassc-rails', '~> 2.1.0'

     

       310
       310
        
       gem 'autoprefixer-rails', '10.2.5.1'

     
···

       358
       358
        
       gem 'warning', '~> 1.3.0'

     

       359
       359
        
       

     

       360
       360
        
       group :development do

     

       361
       361
       -
         gem 'lefthook', '~> 1.2.6', require: false

     

       361
       361
       +
         gem 'lefthook', '~> 1.2.7', require: false

     

       362
       362
        
         gem 'rubocop'

     

       363
       363
        
         gem 'solargraph', '~> 0.47.2', require: false

     

       364
       364
        
       

     

       365
       365
        
         gem 'letter_opener_web', '~> 2.0.0'

     

       366
       366
       -
         gem 'lookbook', '~> 1.2', '>= 1.2.1'

     

       366
       366
       +
         gem 'lookbook', '~> 1.4', '>= 1.4.5'

     

       367
       367
        
       

     

       368
       368
        
         # Better errors handler

     

       369
       369
        
         gem 'better_errors', '~> 2.9.1'

     
···

       395
       395
        
         gem 'spring', '~> 4.1.0'

     

       396
       396
        
         gem 'spring-commands-rspec', '~> 1.0.4'

     

       397
       397
        
       

     

       398
       398
       -
         gem 'gitlab-styles', '~> 9.1.0', require: false

     

       398
       398
       +
         gem 'gitlab-styles', '~> 9.2.0', require: false

     

       399
       399
        
       

     

       400
       400
        
         gem 'haml_lint', '~> 0.40.0', require: false

     

       401
       401
        
         gem 'bundler-audit', '~> 0.7.0.1', require: false

     
···

       538
       538
        
       gem 'microsoft_graph_mailer', '~> 0.1.0', path: 'vendor/gems/microsoft_graph_mailer'

     

       539
       539
        
       

     

       540
       540
        
       # File encryption

     

       541
       541
       -
       gem 'lockbox', '~> 0.6.2'

     

       541
       541
       +
       gem 'lockbox', '~> 1.1.1'

     

       542
       542
        
       

     

       543
       543
        
       # Email validation

     

       544
       544
        
       gem 'valid_email', '~> 0.1'

     
···

       574
       574
        
       

     

       575
       575
        
       # Apple plist parsing

     

       576
       576
        
       gem 'CFPropertyList'

     

       577
       577
       +
       gem 'app_store_connect'

     

       577
       578
        
       

     

       578
       579
        
       # For phone verification

     

       579
       580
        
       gem 'telesignenterprise', '~> 2.2'

+27 -23

pkgs/applications/version-management/gitlab/rubyEnv/Gemfile.lock

···

       172
       172
        
           apollo_upload_server (2.1.0)

     

       173
       173
        
             actionpack (>= 4.2)

     

       174
       174
        
             graphql (>= 1.8)

     

       175
       175
       +
           app_store_connect (0.29.0)

     

       176
       176
       +
             activesupport (>= 6.0.0)

     

       177
       177
       +
             jwt (>= 1.4, <= 2.5.0)

     

       175
       178
        
           arr-pm (0.0.12)

     

       176
       179
        
           asana (0.10.13)

     

       177
       180
        
             faraday (~> 1.0)

     
···

       598
       601
        
           gitlab-sidekiq-fetcher (0.9.0)

     

       599
       602
        
             json (>= 2.5)

     

       600
       603
        
             sidekiq (~> 6.1)

     

       601
       601
       -
           gitlab-styles (9.1.0)

     

       604
       604
       +
           gitlab-styles (9.2.0)

     

       602
       605
        
             rubocop (~> 1.38.0)

     

       603
       606
        
             rubocop-gitlab-security (~> 0.1.1)

     

       604
       607
        
             rubocop-graphql (~> 0.14)

     
···

       832
       835
        
             kramdown (~> 2.0)

     

       833
       836
        
           launchy (2.5.0)

     

       834
       837
        
             addressable (~> 2.7)

     

       835
       835
       -
           lefthook (1.2.6)

     

       838
       838
       +
           lefthook (1.2.7)

     

       836
       839
        
           letter_opener (1.7.0)

     

       837
       840
        
             launchy (~> 2.2)

     

       838
       841
        
           letter_opener_web (2.0.0)

     
···

       861
       864
        
             ffi-compiler (~> 1.0)

     

       862
       865
        
             rake (~> 13.0)

     

       863
       866
        
           locale (2.1.3)

     

       864
       864
       -
           lockbox (0.6.2)

     

       867
       867
       +
           lockbox (1.1.1)

     

       865
       868
        
           lograge (0.11.2)

     

       866
       869
        
             actionpack (>= 4)

     

       867
       870
        
             activesupport (>= 4)

     
···

       870
       873
        
           loofah (2.19.1)

     

       871
       874
        
             crass (~> 1.0.2)

     

       872
       875
        
             nokogiri (>= 1.5.9)

     

       873
       873
       -
           lookbook (1.2.1)

     

       876
       876
       +
           lookbook (1.4.5)

     

       874
       877
        
             actioncable

     

       875
       878
        
             activemodel

     

       876
       879
        
             css_parser

     
···

       930
       933
        
           nenv (0.3.0)

     

       931
       934
        
           net-http-persistent (4.0.1)

     

       932
       935
        
             connection_pool (~> 2.2)

     

       933
       933
       -
           net-ldap (0.16.3)

     

       936
       936
       +
           net-ldap (0.17.1)

     

       934
       937
        
           net-ntp (2.1.3)

     

       935
       938
        
           net-scp (3.0.0)

     

       936
       939
        
             net-ssh (>= 2.6.5, < 7.0.0)

     
···

       1068
       1071
        
             tty-color (~> 0.5)

     

       1069
       1072
        
           peek (1.1.0)

     

       1070
       1073
        
             railties (>= 4.0.0)

     

       1071
       1071
       -
           pg (1.4.3)

     

       1074
       1074
       +
           pg (1.4.5)

     

       1072
       1075
        
           pg_query (2.2.0)

     

       1073
       1076
        
             google-protobuf (>= 3.19.2)

     

       1074
       1077
        
           plist (3.6.0)

     
···

       1108
       1111
        
           pyu-ruby-sasl (0.0.3.3)

     

       1109
       1112
        
           raabro (1.4.0)

     

       1110
       1113
        
           racc (1.6.1)

     

       1111
       1111
       -
           rack (2.2.4)

     

       1114
       1114
       +
           rack (2.2.6.2)

     

       1112
       1115
        
           rack-accept (0.4.5)

     

       1113
       1116
        
             rack (>= 0.4)

     

       1114
       1117
        
           rack-attack (6.6.1)

     
···

       1123
       1126
        
             rack (>= 2.1.0)

     

       1124
       1127
        
           rack-protection (2.2.2)

     

       1125
       1128
        
             rack

     

       1126
       1126
       -
           rack-proxy (0.7.4)

     

       1129
       1129
       +
           rack-proxy (0.7.6)

     

       1127
       1130
        
             rack

     

       1128
       1131
        
           rack-test (2.0.2)

     

       1129
       1132
        
             rack (>= 1.3)

     
···

       1150
       1153
        
           rails-dom-testing (2.0.3)

     

       1151
       1154
        
             activesupport (>= 4.2.0)

     

       1152
       1155
        
             nokogiri (>= 1.6)

     

       1153
       1153
       -
           rails-html-sanitizer (1.4.3)

     

       1154
       1154
       -
             loofah (~> 2.3)

     

       1156
       1156
       +
           rails-html-sanitizer (1.4.4)

     

       1157
       1157
       +
             loofah (~> 2.19, >= 2.19.1)

     

       1155
       1158
        
           rails-i18n (7.0.3)

     

       1156
       1159
        
             i18n (>= 0.7, < 2)

     

       1157
       1160
        
             railties (>= 6.0.0, < 8)

     
···

       1174
       1177
        
           rchardet (1.8.0)

     

       1175
       1178
        
           rdoc (6.3.2)

     

       1176
       1179
        
           re2 (1.6.0)

     

       1177
       1177
       -
           recaptcha (4.13.1)

     

       1180
       1180
       +
           recaptcha (5.12.3)

     

       1178
       1181
        
             json

     

       1179
       1182
        
           recursive-open-struct (1.1.3)

     

       1180
       1183
        
           redcarpet (3.5.1)

     
···

       1274
       1277
        
             rubocop (>= 0.51)

     

       1275
       1278
        
           rubocop-graphql (0.18.0)

     

       1276
       1279
        
             rubocop (>= 0.87, < 2)

     

       1277
       1277
       -
           rubocop-performance (1.15.0)

     

       1280
       1280
       +
           rubocop-performance (1.15.1)

     

       1278
       1281
        
             rubocop (>= 1.7.0, < 2.0)

     

       1279
       1282
        
             rubocop-ast (>= 0.4.0)

     

       1280
       1280
       -
           rubocop-rails (2.17.2)

     

       1283
       1283
       +
           rubocop-rails (2.17.3)

     

       1281
       1284
        
             activesupport (>= 4.2.0)

     

       1282
       1285
        
             rack (>= 1.1)

     

       1283
       1286
        
             rubocop (>= 1.33.0, < 2.0)

     

       1284
       1284
       -
           rubocop-rspec (2.15.0)

     

       1287
       1287
       +
           rubocop-rspec (2.16.0)

     

       1285
       1288
        
             rubocop (~> 1.33)

     

       1286
       1289
        
           ruby-fogbugz (0.3.0)

     

       1287
       1290
        
             crack (~> 0.4)

     
···

       1581
       1584
        
         addressable (~> 2.8)

     

       1582
       1585
        
         akismet (~> 3.0)

     

       1583
       1586
        
         apollo_upload_server (~> 2.1.0)

     

       1587
       1587
       +
         app_store_connect

     

       1584
       1588
        
         arr-pm (~> 0.0.12)

     

       1585
       1589
        
         asana (~> 0.10.13)

     

       1586
       1590
        
         asciidoctor (~> 2.0.17)

     
···

       1672
       1676
        
         gitlab-net-dns (~> 0.9.1)

     

       1673
       1677
        
         gitlab-omniauth-openid-connect (~> 0.10.0)

     

       1674
       1678
        
         gitlab-sidekiq-fetcher (= 0.9.0)

     

       1675
       1675
       -
         gitlab-styles (~> 9.1.0)

     

       1679
       1679
       +
         gitlab-styles (~> 9.2.0)

     

       1676
       1680
        
         gitlab_chronic_duration (~> 0.10.6.2)

     

       1677
       1681
        
         gitlab_omniauth-ldap (~> 2.2.0)

     

       1678
       1682
        
         gon (~> 6.4.0)

     
···

       1716
       1720
        
         knapsack (~> 1.21.1)

     

       1717
       1721
        
         kramdown (~> 2.3.1)

     

       1718
       1722
        
         kubeclient (~> 4.9.3)!

     

       1719
       1719
       -
         lefthook (~> 1.2.6)

     

       1723
       1723
       +
         lefthook (~> 1.2.7)

     

       1720
       1724
        
         letter_opener_web (~> 2.0.0)

     

       1721
       1725
        
         license_finder (~> 7.0)

     

       1722
       1726
        
         licensee (~> 9.15)

     

       1723
       1727
        
         listen (~> 3.7)

     

       1724
       1724
       -
         lockbox (~> 0.6.2)

     

       1728
       1728
       +
         lockbox (~> 1.1.1)

     

       1725
       1729
        
         lograge (~> 0.5)

     

       1726
       1730
        
         loofah (~> 2.19.1)

     

       1727
       1727
       -
         lookbook (~> 1.2, >= 1.2.1)

     

       1731
       1731
       +
         lookbook (~> 1.4, >= 1.4.5)

     

       1728
       1732
        
         lru_redux

     

       1729
       1733
        
         mail (= 2.7.1)

     

       1730
       1734
        
         mail-smtp_pool (~> 0.1.0)!

     
···

       1734
       1738
        
         mini_magick (~> 4.10.1)

     

       1735
       1739
        
         minitest (~> 5.11.0)

     

       1736
       1740
        
         multi_json (~> 1.14.1)

     

       1737
       1737
       -
         net-ldap (~> 0.16.3)

     

       1741
       1741
       +
         net-ldap (~> 0.17.1)

     

       1738
       1742
        
         net-ntp

     

       1739
       1743
        
         nokogiri (~> 1.13.10)

     

       1740
       1744
        
         oauth2 (~> 2.0)

     
···

       1767
       1771
        
         parallel (~> 1.19)

     

       1768
       1772
        
         parslet (~> 1.8)

     

       1769
       1773
        
         peek (~> 1.1)

     

       1770
       1770
       -
         pg (~> 1.4.3)

     

       1774
       1774
       +
         pg (~> 1.4.5)

     

       1771
       1775
        
         pg_query (~> 2.2)

     

       1772
       1776
        
         png_quantizator (~> 0.2.1)

     

       1773
       1777
        
         premailer-rails (~> 1.10.3)

     
···

       1777
       1781
        
         pry-shell (~> 0.5.1)

     

       1778
       1782
        
         puma (~> 5.6.5)

     

       1779
       1783
        
         puma_worker_killer (~> 0.3.1)

     

       1780
       1780
       -
         rack (~> 2.2.4)

     

       1784
       1784
       +
         rack (~> 2.2.6, >= 2.2.6.2)

     

       1781
       1785
        
         rack-attack (~> 6.6.1)

     

       1782
       1786
        
         rack-cors (~> 1.1.1)

     

       1783
       1787
        
         rack-oauth2 (~> 1.21.3)

     

       1784
       1784
       -
         rack-proxy (~> 0.7.4)

     

       1788
       1788
       +
         rack-proxy (~> 0.7.6)

     

       1785
       1789
        
         rack-timeout (~> 0.6.3)

     

       1786
       1790
        
         rails (~> 6.1.6.1)

     

       1787
       1791
        
         rails-controller-testing

     
···

       1790
       1794
        
         rbtrace (~> 0.4)

     

       1791
       1795
        
         rdoc (~> 6.3.2)

     

       1792
       1796
        
         re2 (~> 1.6.0)

     

       1793
       1793
       -
         recaptcha (~> 4.11)

     

       1797
       1797
       +
         recaptcha (~> 5.12)

     

       1794
       1798
        
         redis (~> 4.8.0)

     

       1795
       1799
        
         redis-actionpack (~> 5.3.0)

     

       1796
       1800
        
         redis-namespace (~> 1.9.0)

+37 -26

pkgs/applications/version-management/gitlab/rubyEnv/gemset.nix

···

       206
       206
        
           };

     

       207
       207
        
           version = "2.1.0";

     

       208
       208
        
         };

     

       209
       209
       +
         app_store_connect = {

     

       210
       210
       +
           dependencies = ["activesupport" "jwt"];

     

       211
       211
       +
           groups = ["default"];

     

       212
       212
       +
           platforms = [];

     

       213
       213
       +
           source = {

     

       214
       214
       +
             remotes = ["https://rubygems.org"];

     

       215
       215
       +
             sha256 = "03s3x8b6ifjrqk9ian59i9yyxxl65ykvbb4r424j2hjsh8iskmq1";

     

       216
       216
       +
             type = "gem";

     

       217
       217
       +
           };

     

       218
       218
       +
           version = "0.29.0";

     

       219
       219
       +
         };

     

       209
       220
        
         arr-pm = {

     

       210
       221
        
           groups = ["default"];

     

       211
       222
        
           platforms = [];

     
···

       2177
       2188
        
           platforms = [];

     

       2178
       2189
        
           source = {

     

       2179
       2190
        
             remotes = ["https://rubygems.org"];

     

       2180
       2180
       -
             sha256 = "1ch27hxbby16jxvxg1jq3sqdbd3gg7ss4ymxn3yhsjy7gyglxza6";

     

       2191
       2191
       +
             sha256 = "196fhlbhhanpbn5iriccp7m04xgkq7swyk07im50q7z05pxyf1ki";

     

       2181
       2192
        
             type = "gem";

     

       2182
       2193
        
           };

     

       2183
       2183
       -
           version = "9.1.0";

     

       2194
       2194
       +
           version = "9.2.0";

     

       2184
       2195
        
         };

     

       2185
       2196
        
         gitlab_chronic_duration = {

     

       2186
       2197
        
           dependencies = ["numerizer"];

     
···

       3098
       3109
        
           platforms = [];

     

       3099
       3110
        
           source = {

     

       3100
       3111
        
             remotes = ["https://rubygems.org"];

     

       3101
       3101
       -
             sha256 = "0qyylcc57pcf8mwm9dvlzkfjxcpbypnp4q21ni05s7wxalxb12ld";

     

       3112
       3112
       +
             sha256 = "18vcakjkb5fhavq9s6j7zwjc14c652361qws5g1slqb300anfww2";

     

       3102
       3113
        
             type = "gem";

     

       3103
       3114
        
           };

     

       3104
       3104
       -
           version = "1.2.6";

     

       3115
       3115
       +
           version = "1.2.7";

     

       3105
       3116
        
         };

     

       3106
       3117
        
         letter_opener = {

     

       3107
       3118
        
           dependencies = ["launchy"];

     
···

       3194
       3205
        
           platforms = [];

     

       3195
       3206
        
           source = {

     

       3196
       3207
        
             remotes = ["https://rubygems.org"];

     

       3197
       3197
       -
             sha256 = "0g6w327y8d7dr0d7zw6p7hmlwh0hcvb7pkc7xxyf5mn3fmw6fdh1";

     

       3208
       3208
       +
             sha256 = "1h1a3h3rfv3094pn5zn7d3c066dmhx9i380mhqa1qyagqla6pw8a";

     

       3198
       3209
        
             type = "gem";

     

       3199
       3210
        
           };

     

       3200
       3200
       -
           version = "0.6.2";

     

       3211
       3211
       +
           version = "1.1.1";

     

       3201
       3212
        
         };

     

       3202
       3213
        
         lograge = {

     

       3203
       3214
        
           dependencies = ["actionpack" "activesupport" "railties" "request_store"];

     
···

       3227
       3238
        
           platforms = [];

     

       3228
       3239
        
           source = {

     

       3229
       3240
        
             remotes = ["https://rubygems.org"];

     

       3230
       3230
       -
             sha256 = "1mv5q4gpgzklwrgp7s7mhi0gb7x739qhyrni2n96i2vr4nv48a3l";

     

       3241
       3241
       +
             sha256 = "1nww5h9frmbjfpfy2nb296vn78xnq1qg0lq3lsn52ky8s8rb65dw";

     

       3231
       3242
        
             type = "gem";

     

       3232
       3243
        
           };

     

       3233
       3233
       -
           version = "1.2.1";

     

       3244
       3244
       +
           version = "1.4.5";

     

       3234
       3245
        
         };

     

       3235
       3246
        
         lru_redux = {

     

       3236
       3247
        
           groups = ["default"];

     
···

       3581
       3592
        
           platforms = [];

     

       3582
       3593
        
           source = {

     

       3583
       3594
        
             remotes = ["https://rubygems.org"];

     

       3584
       3584
       -
             sha256 = "13lh6qizxi8fza8py73b2dvjp9p010dvbaq7diagir9nh8plsinv";

     

       3595
       3595
       +
             sha256 = "1ycw0qsw3hap8svakl0i30jkj0ffd4lpyrn17a1j0w8mz5ainmsj";

     

       3585
       3596
        
             type = "gem";

     

       3586
       3597
        
           };

     

       3587
       3587
       -
           version = "0.16.3";

     

       3598
       3598
       +
           version = "0.17.1";

     

       3588
       3599
        
         };

     

       3589
       3600
        
         net-ntp = {

     

       3590
       3601
        
           groups = ["default"];

     
···

       4153
       4164
        
           platforms = [];

     

       4154
       4165
        
           source = {

     

       4155
       4166
        
             remotes = ["https://rubygems.org"];

     

       4156
       4156
       -
             sha256 = "1ypj64nhq3grs9zh40vmyfyhmxlhljjsbg5q0jxhlxg5v76ij0mb";

     

       4167
       4167
       +
             sha256 = "1wd6nl81nbdwck04hccsm7wf23ghpi8yddd9j4rbwyvyj0sbsff1";

     

       4157
       4168
        
             type = "gem";

     

       4158
       4169
        
           };

     

       4159
       4159
       -
           version = "1.4.3";

     

       4170
       4170
       +
           version = "1.4.5";

     

       4160
       4171
        
         };

     

       4161
       4172
        
         pg_query = {

     

       4162
       4173
        
           dependencies = ["google-protobuf"];

     
···

       4358
       4369
        
           platforms = [];

     

       4359
       4370
        
           source = {

     

       4360
       4371
        
             remotes = ["https://rubygems.org"];

     

       4361
       4361
       -
             sha256 = "0axc6w0rs4yj0pksfll1hjgw1k6a5q0xi2lckh91knfb72v348pa";

     

       4372
       4372
       +
             sha256 = "0qvp6h2abmlsl4sqjsvac03cr2mxq6143gbx4kq52rpazp021qsb";

     

       4362
       4373
        
             type = "gem";

     

       4363
       4374
        
           };

     

       4364
       4364
       -
           version = "2.2.4";

     

       4375
       4375
       +
           version = "2.2.6.2";

     

       4365
       4376
        
         };

     

       4366
       4377
        
         rack-accept = {

     

       4367
       4378
        
           dependencies = ["rack"];

     
···

       4424
       4435
        
           platforms = [];

     

       4425
       4436
        
           source = {

     

       4426
       4437
        
             remotes = ["https://rubygems.org"];

     

       4427
       4427
       -
             sha256 = "1m6j2xk3s3ps3r9vqgwq3flyij9jgkyzanmgiifid8yqhcskgfx8";

     

       4438
       4438
       +
             sha256 = "1a62439xwn5v6hsl9s11hdk4wj58czhcbg7lminv23mnkc0ca147";

     

       4428
       4439
        
             type = "gem";

     

       4429
       4440
        
           };

     

       4430
       4430
       -
           version = "0.7.4";

     

       4441
       4441
       +
           version = "0.7.6";

     

       4431
       4442
        
         };

     

       4432
       4443
        
         rack-test = {

     

       4433
       4444
        
           dependencies = ["rack"];

     
···

       4489
       4500
        
           platforms = [];

     

       4490
       4501
        
           source = {

     

       4491
       4502
        
             remotes = ["https://rubygems.org"];

     

       4492
       4492
       -
             sha256 = "1mj0b7ay10a2fgwj70kjw7mlyrp7a5la8lx8zmwhy40bkansdfrf";

     

       4503
       4503
       +
             sha256 = "1mcb75qvldfz6zsr4inrfx7dmb0ngxy507awx28khqmnla3hqpc9";

     

       4493
       4504
        
             type = "gem";

     

       4494
       4505
        
           };

     

       4495
       4495
       -
           version = "1.4.3";

     

       4506
       4506
       +
           version = "1.4.4";

     

       4496
       4507
        
         };

     

       4497
       4508
        
         rails-i18n = {

     

       4498
       4509
        
           dependencies = ["i18n" "railties"];

     
···

       4614
       4625
        
           platforms = [];

     

       4615
       4626
        
           source = {

     

       4616
       4627
        
             remotes = ["https://rubygems.org"];

     

       4617
       4617
       -
             sha256 = "121pkq8kwqjh4l751xzx15bjp5vmf5pirfmpb11h71zsiavjqv6w";

     

       4628
       4628
       +
             sha256 = "1vmpppgdy64qa16bvkss0xyzmyyzxv5hwzvc1i6saw4yvm58kl9p";

     

       4618
       4629
        
             type = "gem";

     

       4619
       4630
        
           };

     

       4620
       4620
       -
           version = "4.13.1";

     

       4631
       4631
       +
           version = "5.12.3";

     

       4621
       4632
        
         };

     

       4622
       4633
        
         recursive-open-struct = {

     

       4623
       4634
        
           groups = ["default"];

     
···

       5020
       5031
        
           platforms = [];

     

       5021
       5032
        
           source = {

     

       5022
       5033
        
             remotes = ["https://rubygems.org"];

     

       5023
       5023
       -
             sha256 = "1h06a2asg8pjq7l0k885126n60y54rgw0qr957qarpv7qligzn4c";

     

       5034
       5034
       +
             sha256 = "00ld0hfm2x5hzms9xhkyjfxs8afsmlg1kf0mklk68cq4wwwihkwd";

     

       5024
       5035
        
             type = "gem";

     

       5025
       5036
        
           };

     

       5026
       5026
       -
           version = "1.15.0";

     

       5037
       5037
       +
           version = "1.15.1";

     

       5027
       5038
        
         };

     

       5028
       5039
        
         rubocop-rails = {

     

       5029
       5040
        
           dependencies = ["activesupport" "rack" "rubocop"];

     
···

       5031
       5042
        
           platforms = [];

     

       5032
       5043
        
           source = {

     

       5033
       5044
        
             remotes = ["https://rubygems.org"];

     

       5034
       5034
       -
             sha256 = "052viwgi7dbbnq0pxihz1k72dwhph8gw4v2zzw057w42l39hhh6i";

     

       5045
       5045
       +
             sha256 = "1bv51vwcg5m4v35n7653xclw9vv3ifvgbhvc2l79wz2p76ipm1bx";

     

       5035
       5046
        
             type = "gem";

     

       5036
       5047
        
           };

     

       5037
       5037
       -
           version = "2.17.2";

     

       5048
       5048
       +
           version = "2.17.3";

     

       5038
       5049
        
         };

     

       5039
       5050
        
         rubocop-rspec = {

     

       5040
       5051
        
           dependencies = ["rubocop"];

     
···

       5042
       5053
        
           platforms = [];

     

       5043
       5054
        
           source = {

     

       5044
       5055
        
             remotes = ["https://rubygems.org"];

     

       5045
       5045
       -
             sha256 = "0pj53m5zcrgyhb2zsjxqsav9sm9s8jh0mgk8c1qckaxy3dkwfxm4";

     

       5056
       5056
       +
             sha256 = "1rpcww107xq6aj5wkypzjj346jaxhqal33wmhlwb9gc2h425yg5k";

     

       5046
       5057
        
             type = "gem";

     

       5047
       5058
        
           };

     

       5048
       5048
       -
           version = "2.15.0";

     

       5059
       5059
       +
           version = "2.16.0";

     

       5049
       5060
        
         };

     

       5050
       5061
        
         ruby-fogbugz = {

     

       5051
       5062
        
           dependencies = ["crack" "multipart-post"];

+2 -2

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

···

       4
       4
        
       

     

       5
       5
        
       stdenv.mkDerivation rec {

     

       6
       6
        
         pname = "got";

     

       7
       7
       -
         version = "0.82";

     

       7
       7
       +
         version = "0.83";

     

       8
       8
        
       

     

       9
       9
        
         src = fetchurl {

     

       10
       10
        
           url = "https://gameoftrees.org/releases/portable/got-portable-${version}.tar.gz";

     

       11
       11
       -
           sha256 = "sha256-Lb0WZ4gTuG/GBAnEh9ff/K0ciwjDX3cmEhItMyJ/lmI=";

     

       11
       11
       +
           sha256 = "sha256-kNhU6OR9IUNPL72D90nhq2X5vmVW7YUmpnq/EOUvG/8=";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         nativeBuildInputs = [ pkg-config bison ];

+2 -2

pkgs/applications/version-management/sublime-merge/default.nix

···

       9
       9
        
         } {};

     

       10
       10
        
       

     

       11
       11
        
         sublime-merge-dev = common {

     

       12
       12
       -
           buildVersion = "2081";

     

       13
       13
       -
           x64sha256 = "QzJP25KxczmrR5PZ9ujRSM3V+TrKqiH82plo1bTv48s=";

     

       12
       12
       +
           buildVersion = "2082";

     

       13
       13
       +
           x64sha256 = "Gl1BrLTSDLRTgrYQW/99o0XRjSIxvnNYRIViZEidcsM=";

     

       14
       14
        
           dev = true;

     

       15
       15
        
         } {};

     

       16
       16
        
       }

+3 -3

pkgs/applications/virtualization/crun/default.nix

···

       38
       38
        
       in

     

       39
       39
        
       stdenv.mkDerivation rec {

     

       40
       40
        
         pname = "crun";

     

       41
       41
       -
         version = "1.7.2";

     

       41
       41
       +
         version = "1.8";

     

       42
       42
        
       

     

       43
       43
        
         src = fetchFromGitHub {

     

       44
       44
        
           owner = "containers";

     

       45
       45
        
           repo = pname;

     

       46
       46
        
           rev = version;

     

       47
       47
       -
           sha256 = "sha256-SNNy/oI3ZcMeRLEMS2nSCS/rRaen5WsDfhdlHQCdtP4=";

     

       47
       47
       +
           hash = "sha256-8R9cja8Blk+7Sp25bJ9t9e0TvazD41livK+KKAwRpLg=";

     

       48
       48
        
           fetchSubmodules = true;

     

       49
       49
        
         };

     

       50
       50
        
       

     
···

       74
       74
        
       

     

       75
       75
        
         meta = with lib; {

     

       76
       76
        
           description = "A fast and lightweight fully featured OCI runtime and C library for running containers";

     

       77
       77
       +
           homepage = "https://github.com/containers/crun";

     

       77
       78
        
           license = licenses.gpl2Plus;

     

       78
       79
        
           platforms = platforms.linux;

     

       79
       79
       -
           inherit (src.meta) homepage;

     

       80
       80
        
           maintainers = with maintainers; [ ] ++ teams.podman.members;

     

       81
       81
        
         };

     

       82
       82
        
       }

+30 -26

pkgs/applications/virtualization/docker/default.nix

···

       2
       2
        
       

     

       3
       3
        
       rec {

     

       4
       4
        
         dockerGen = {

     

       5
       5
       -
             version, rev, sha256

     

       6
       6
       -
             , moby-src

     

       7
       7
       -
             , runcRev, runcSha256

     

       8
       8
       -
             , containerdRev, containerdSha256

     

       9
       9
       -
             , tiniRev, tiniSha256, buildxSupport ? true, composeSupport ? true

     

       5
       5
       +
             version

     

       6
       6
       +
             , cliRev, cliHash

     

       7
       7
       +
             , mobyRev, mobyHash

     

       8
       8
       +
             , runcRev, runcHash

     

       9
       9
       +
             , containerdRev, containerdHash

     

       10
       10
       +
             , tiniRev, tiniHash, buildxSupport ? true, composeSupport ? true

     

       10
       11
        
             # package dependencies

     

       11
       12
        
             , stdenv, fetchFromGitHub, fetchpatch, buildGoPackage

     

       12
       13
        
             , makeWrapper, installShellFiles, pkg-config, glibc

     
···

       29
       30
        
               owner = "opencontainers";

     

       30
       31
        
               repo = "runc";

     

       31
       32
        
               rev = runcRev;

     

       32
       32
       -
               sha256 = runcSha256;

     

       33
       33
       +
               hash = runcHash;

     

       33
       34
        
             };

     

       34
       35
        
       

     

       35
       36
        
             # docker/runc already include these patches / are not applicable

     
···

       44
       45
        
               owner = "containerd";

     

       45
       46
        
               repo = "containerd";

     

       46
       47
        
               rev = containerdRev;

     

       47
       47
       -
               sha256 = containerdSha256;

     

       48
       48
       +
               hash = containerdHash;

     

       48
       49
        
             };

     

       49
       50
        
       

     

       50
       51
        
             buildInputs = oldAttrs.buildInputs

     
···

       59
       60
        
               owner = "krallin";

     

       60
       61
        
               repo = "tini";

     

       61
       62
        
               rev = tiniRev;

     

       62
       62
       -
               sha256 = tiniSha256;

     

       63
       63
       +
               hash = tiniHash;

     

       63
       64
        
             };

     

       64
       65
        
       

     

       65
       66
        
             # Do not remove static from make files as we want a static binary

     
···

       70
       71
        
             NIX_CFLAGS_COMPILE = "-DMINIMAL=ON";

     

       71
       72
        
           });

     

       72
       73
        
       

     

       74
       74
       +
           moby-src = fetchFromGitHub {

     

       75
       75
       +
             owner = "moby";

     

       76
       76
       +
             repo = "moby";

     

       77
       77
       +
             rev = mobyRev;

     

       78
       78
       +
             hash = mobyHash;

     

       79
       79
       +
           };

     

       80
       80
       +
       

     

       73
       81
        
           moby = buildGoPackage (lib.optionalAttrs stdenv.isLinux rec {

     

       74
       82
        
             pname = "moby";

     

       75
       83
        
             inherit version;

     
···

       95
       103
        
               (fetchpatch {

     

       96
       104
        
                 name = "buildkit-zfs.patch";

     

       97
       105
        
                 url = "https://github.com/moby/moby/pull/43136.patch";

     

       98
       98
       -
                 sha256 = "1WZfpVnnqFwLMYqaHLploOodls0gHF8OCp7MrM26iX8=";

     

       106
       106
       +
                 hash = "sha256-1WZfpVnnqFwLMYqaHLploOodls0gHF8OCp7MrM26iX8=";

     

       99
       107
        
               })

     

       100
       108
        
             ];

     

       101
       109
        
       

     
···

       108
       116
        
               # build engine

     

       109
       117
        
               cd ./go/src/${goPackagePath}

     

       110
       118
        
               export AUTO_GOPATH=1

     

       111
       111
       -
               export DOCKER_GITCOMMIT="${rev}"

     

       119
       119
       +
               export DOCKER_GITCOMMIT="${cliRev}"

     

       112
       120
        
               export VERSION="${version}"

     

       113
       121
        
               ./hack/make.sh dynbinary

     

       114
       122
        
               cd -

     
···

       159
       167
        
           src = fetchFromGitHub {

     

       160
       168
        
             owner = "docker";

     

       161
       169
        
             repo = "cli";

     

       162
       162
       -
             rev = "v${version}";

     

       163
       163
       -
             sha256 = sha256;

     

       170
       170
       +
             rev = cliRev;

     

       171
       171
       +
             hash = cliHash;

     

       164
       172
        
           };

     

       165
       173
        
       

     

       166
       174
        
           goPackagePath = "github.com/docker/cli";

     
···

       192
       200
        
             mkdir -p .gopath/src/github.com/docker/

     

       193
       201
        
             ln -sf $PWD .gopath/src/github.com/docker/cli

     

       194
       202
        
             export GOPATH="$PWD/.gopath:$GOPATH"

     

       195
       195
       -
             export GITCOMMIT="${rev}"

     

       203
       203
       +
             export GITCOMMIT="${cliRev}"

     

       196
       204
        
             export VERSION="${version}"

     

       197
       205
        
             export BUILDTIME="1970-01-01T00:00:00Z"

     

       198
       206
        
             source ./scripts/build/.variables

     
···

       254
       262
        
         # Get revisions from

     

       255
       263
        
         # https://github.com/moby/moby/tree/${version}/hack/dockerfile/install/*

     

       256
       264
        
         docker_20_10 = callPackage dockerGen rec {

     

       257
       257
       -
           version = "20.10.21";

     

       258
       258
       -
           rev = "v${version}";

     

       259
       259
       -
           sha256 = "sha256-hPQ1t7L2fqoFWoinqIrDwFQ1bo9TzMb4l3HmAotIUS8=";

     

       260
       260
       -
           moby-src = fetchFromGitHub {

     

       261
       261
       -
             owner = "moby";

     

       262
       262
       -
             repo = "moby";

     

       263
       263
       -
             rev = "v${version}";

     

       264
       264
       -
             sha256 = "sha256-BcYDh/UEmmURt7hWLWdPTKVu/Nzoeq/shE+HnUoh8b4=";

     

       265
       265
       -
           };

     

       265
       265
       +
           version = "20.10.23";

     

       266
       266
       +
           cliRev = "v${version}";

     

       267
       267
       +
           cliHash = "sha256-fNaRpstyG90Jzq3+U2A42Jj+ixb+m7tXLioIcsegPbQ=";

     

       268
       268
       +
           mobyRev = "v${version}";

     

       269
       269
       +
           mobyHash = "sha256-nBPw/M4VC9XeZ9S33HWdWSjY2J2mYpI/TPOzvLjSmJM=";

     

       266
       270
        
           runcRev = "v1.1.4";

     

       267
       267
       -
           runcSha256 = "sha256-ougJHW1Z+qZ324P8WpZqawY1QofKnn8WezP7orzRTdA=";

     

       268
       268
       -
           containerdRev = "v1.6.9";

     

       269
       269
       -
           containerdSha256 = "sha256-KvQdYQLzgt/MKPsA/mO5un6nE3/xcvVYwIveNn/uDnU=";

     

       271
       271
       +
           runcHash = "sha256-ougJHW1Z+qZ324P8WpZqawY1QofKnn8WezP7orzRTdA=";

     

       272
       272
       +
           containerdRev = "v1.6.15";

     

       273
       273
       +
           containerdHash = "sha256-Vlftq//mLYZPoT2R/lHJA6wLnqiuC+Cpy4lGQC8jCPA=";

     

       270
       274
        
           tiniRev = "v0.19.0";

     

       271
       271
       -
           tiniSha256 = "sha256-ZDKu/8yE5G0RYFJdhgmCdN3obJNyRWv6K/Gd17zc1sI=";

     

       275
       275
       +
           tiniHash = "sha256-ZDKu/8yE5G0RYFJdhgmCdN3obJNyRWv6K/Gd17zc1sI=";

     

       272
       276
        
         };

     

       273
       277
        
       }

+1 -1

pkgs/build-support/rust/build-rust-crate/configure-crate.nix

···

       130
       130
        
         export CARGO_CFG_UNIX=1

     

       131
       131
        
         export CARGO_CFG_TARGET_ENV="gnu"

     

       132
       132
        
         export CARGO_CFG_TARGET_ENDIAN=${if stdenv.hostPlatform.parsed.cpu.significantByte.name == "littleEndian" then "little" else "big"}

     

       133
       133
       -
         export CARGO_CFG_TARGET_POINTER_WIDTH=${toString stdenv.hostPlatform.parsed.cpu.bits}

     

       133
       133
       +
         export CARGO_CFG_TARGET_POINTER_WIDTH=${with stdenv.hostPlatform; toString (if isILP32 then 32 else parsed.cpu.bits)}

     

       134
       134
        
         export CARGO_CFG_TARGET_VENDOR=${stdenv.hostPlatform.parsed.vendor.name}

     

       135
       135
        
       

     

       136
       136
        
         export CARGO_MANIFEST_DIR=$(pwd)

+2 -2

pkgs/data/fonts/cozette/default.nix

···

       2
       2
        
       

     

       3
       3
        
       stdenvNoCC.mkDerivation rec {

     

       4
       4
        
         pname = "cozette";

     

       5
       5
       -
         version = "1.13.0";

     

       5
       5
       +
         version = "1.19.0";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchzip {

     

       8
       8
        
           url = "https://github.com/slavfox/Cozette/releases/download/v.${version}/CozetteFonts.zip";

     

       9
       9
       -
           hash = "sha256-bMgjNnm84vk7jT2UvgCeQwmjZ+9X1GzGLXIEukhaWGw=";

     

       9
       9
       +
           hash = "sha256-nlEnQjQJAFRvZgdGMiloMs4afugmSFnITTIHD+Qkggg=";

     

       10
       10
        
         };

     

       11
       11
        
       

     

       12
       12
        
         installPhase = ''

+42

pkgs/data/fonts/roboto-serif/default.nix

···

       1
       1
       +
       { lib

     

       2
       2
       +
       , stdenvNoCC

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       , unzip

     

       5
       5
       +
       }:

     

       6
       6
       +
       

     

       7
       7
       +
       stdenvNoCC.mkDerivation rec {

     

       8
       8
       +
         pname = "roboto-serif";

     

       9
       9
       +
         version = "1.007";

     

       10
       10
       +
       

     

       11
       11
       +
         src = fetchurl {

     

       12
       12
       +
           url = "https://github.com/googlefonts/roboto-serif/releases/download/v${version}/RobotoSerifFonts-v${version}.zip";

     

       13
       13
       +
           hash = "sha256-A14GztkTvaLBvcm1i3A0Vi9vaz77nFYYoSNggqbffFo=";

     

       14
       14
       +
         };

     

       15
       15
       +
       

     

       16
       16
       +
         sourceRoot = ".";

     

       17
       17
       +
       

     

       18
       18
       +
         nativeBuildInputs = [

     

       19
       19
       +
           unzip

     

       20
       20
       +
         ];

     

       21
       21
       +
       

     

       22
       22
       +
         installPhase = ''

     

       23
       23
       +
           runHook preInstall

     

       24
       24
       +
       

     

       25
       25
       +
           install -Dm644 variable/*.ttf -t $out/share/fonts/truetype

     

       26
       26
       +
       

     

       27
       27
       +
           runHook postInstall

     

       28
       28
       +
         '';

     

       29
       29
       +
       

     

       30
       30
       +
         meta = with lib; {

     

       31
       31
       +
           description = "The Roboto family of fonts";

     

       32
       32
       +
           longDescription = ''

     

       33
       33
       +
             Google’s signature family of fonts, the default font on Android and

     

       34
       34
       +
             Chrome OS, and the recommended font for Google’s visual language,

     

       35
       35
       +
             Material Design.

     

       36
       36
       +
           '';

     

       37
       37
       +
           homepage = "https://github.com/googlefonts/roboto-serif";

     

       38
       38
       +
           license = licenses.ofl;

     

       39
       39
       +
           maintainers = with maintainers; [ wegank ];

     

       40
       40
       +
           platforms = platforms.all;

     

       41
       41
       +
         };

     

       42
       42
       +
       }

+2 -2

pkgs/data/icons/numix-icon-theme-circle/default.nix

···

       2
       2
        
       

     

       3
       3
        
       stdenvNoCC.mkDerivation rec {

     

       4
       4
        
         pname = "numix-icon-theme-circle";

     

       5
       5
       -
         version = "23.01.25";

     

       5
       5
       +
         version = "23.01.29";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "numixproject";

     

       9
       9
        
           repo = pname;

     

       10
       10
        
           rev = version;

     

       11
       11
       -
           sha256 = "sha256-bejoClo31C2gO7Ni1cIxaumwDrhumRZgAPpxS1Jt/Fw=";

     

       11
       11
       +
           sha256 = "sha256-VmVzU8ACBE4Rx0uVScdQVbygDLE9MmD7ssD1j4ri74g=";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         nativeBuildInputs = [ gtk3 ];

+2 -2

pkgs/data/icons/numix-icon-theme-square/default.nix

···

       2
       2
        
       

     

       3
       3
        
       stdenvNoCC.mkDerivation rec {

     

       4
       4
        
         pname = "numix-icon-theme-square";

     

       5
       5
       -
         version = "23.01.25";

     

       5
       5
       +
         version = "23.01.29";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "numixproject";

     

       9
       9
        
           repo = pname;

     

       10
       10
        
           rev = version;

     

       11
       11
       -
           sha256 = "sha256-ZScDymdtrDTCrLB9Fp3zxBQt0A3qz0vN1OhBCK5K/HQ=";

     

       11
       11
       +
           sha256 = "sha256-uHy1HXCRlPQh9t9bsvClTmP4FW/sP91hYKUXxtdBmdw=";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         nativeBuildInputs = [ gtk3 ];

+76

pkgs/desktops/deepin/apps/deepin-terminal/default.nix

···

       1
       1
       +
       { stdenv

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchFromGitHub

     

       4
       4
       +
       , fetchpatch

     

       5
       5
       +
       , dtkwidget

     

       6
       6
       +
       , qt5integration

     

       7
       7
       +
       , qt5platform-plugins

     

       8
       8
       +
       , dde-qt-dbus-factory

     

       9
       9
       +
       , cmake

     

       10
       10
       +
       , qtbase

     

       11
       11
       +
       , qttools

     

       12
       12
       +
       , qtx11extras

     

       13
       13
       +
       , pkg-config

     

       14
       14
       +
       , wrapQtAppsHook

     

       15
       15
       +
       , at-spi2-core

     

       16
       16
       +
       , libsecret

     

       17
       17
       +
       , chrpath

     

       18
       18
       +
       , lxqt

     

       19
       19
       +
       , gtest

     

       20
       20
       +
       }:

     

       21
       21
       +
       

     

       22
       22
       +
       stdenv.mkDerivation rec {

     

       23
       23
       +
         pname = "deepin-terminal";

     

       24
       24
       +
         version = "5.4.34";

     

       25
       25
       +
       

     

       26
       26
       +
         src = fetchFromGitHub {

     

       27
       27
       +
           owner = "linuxdeepin";

     

       28
       28
       +
           repo = pname;

     

       29
       29
       +
           rev = version;

     

       30
       30
       +
           sha256 = "sha256-CpI7dyQwrYOYzqVZ6aa+/OAUC3xRyY4ZwzH1mqURTfY=";

     

       31
       31
       +
         };

     

       32
       32
       +
       

     

       33
       33
       +
         patches = [

     

       34
       34
       +
           (fetchpatch {

     

       35
       35
       +
             name = "chore: use GNUInstallDirs in CmakeLists";

     

       36
       36
       +
             url = "https://github.com/linuxdeepin/deepin-terminal/commit/b18a2ca8411f09f5573aa2a8403a484b693ec975.patch";

     

       37
       37
       +
             sha256 = "sha256-Qy8Jg+7BfZr8tQEsCAzhMEwf6rU96gkgup5f9bMMELY=";

     

       38
       38
       +
           })

     

       39
       39
       +
         ];

     

       40
       40
       +
       

     

       41
       41
       +
         cmakeFlags = [ "-DVERSION=${version}" ];

     

       42
       42
       +
       

     

       43
       43
       +
         nativeBuildInputs = [

     

       44
       44
       +
           cmake

     

       45
       45
       +
           qttools

     

       46
       46
       +
           pkg-config

     

       47
       47
       +
           wrapQtAppsHook

     

       48
       48
       +
           lxqt.lxqt-build-tools

     

       49
       49
       +
         ];

     

       50
       50
       +
       

     

       51
       51
       +
         buildInputs = [

     

       52
       52
       +
           dtkwidget

     

       53
       53
       +
           qt5platform-plugins

     

       54
       54
       +
           dde-qt-dbus-factory

     

       55
       55
       +
           qtx11extras

     

       56
       56
       +
           at-spi2-core

     

       57
       57
       +
           libsecret

     

       58
       58
       +
           chrpath

     

       59
       59
       +
           gtest

     

       60
       60
       +
         ];

     

       61
       61
       +
       

     

       62
       62
       +
         strictDeps = true;

     

       63
       63
       +
       

     

       64
       64
       +
         # qt5integration must be placed before qtsvg in QT_PLUGIN_PATH

     

       65
       65
       +
         qtWrapperArgs = [

     

       66
       66
       +
           "--prefix QT_PLUGIN_PATH : ${qt5integration}/${qtbase.qtPluginPrefix}"

     

       67
       67
       +
         ];

     

       68
       68
       +
       

     

       69
       69
       +
         meta = with lib; {

     

       70
       70
       +
           description = "Terminal emulator with workspace, multiple windows, remote management, quake mode and other features";

     

       71
       71
       +
           homepage = "https://github.com/linuxdeepin/deepin-terminal";

     

       72
       72
       +
           license = licenses.gpl3Plus;

     

       73
       73
       +
           platforms = platforms.linux;

     

       74
       74
       +
           maintainers = teams.deepin.members;

     

       75
       75
       +
         };

     

       76
       76
       +
       }

+26

pkgs/desktops/deepin/artwork/dde-account-faces/default.nix

···

       1
       1
       +
       { stdenvNoCC

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchFromGitHub

     

       4
       4
       +
       }:

     

       5
       5
       +
       

     

       6
       6
       +
       stdenvNoCC.mkDerivation rec {

     

       7
       7
       +
         pname = "dde-account-faces";

     

       8
       8
       +
         version = "1.0.12.1";

     

       9
       9
       +
       

     

       10
       10
       +
         src = fetchFromGitHub {

     

       11
       11
       +
           owner = "linuxdeepin";

     

       12
       12
       +
           repo = pname;

     

       13
       13
       +
           rev = version;

     

       14
       14
       +
           sha256 = "sha256-NWjR8qxWi2IrcP0cSF+lLxBJ/GrVpk1BfTjVH0ytinY=";

     

       15
       15
       +
         };

     

       16
       16
       +
       

     

       17
       17
       +
         makeFlags = [ "PREFIX=${placeholder "out"}/var" ];

     

       18
       18
       +
       

     

       19
       19
       +
         meta = with lib; {

     

       20
       20
       +
           description = "Account faces of deepin desktop environment";

     

       21
       21
       +
           homepage = "https://github.com/linuxdeepin/dde-account-faces";

     

       22
       22
       +
           license = with licenses; [ gpl3Plus cc0 ];

     

       23
       23
       +
           platforms = platforms.linux;

     

       24
       24
       +
           maintainers = teams.deepin.members;

     

       25
       25
       +
         };

     

       26
       26
       +
       }

+31

pkgs/desktops/deepin/artwork/deepin-gtk-theme/default.nix

···

       1
       1
       +
       { stdenvNoCC

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchFromGitHub

     

       4
       4
       +
       , gtk-engine-murrine

     

       5
       5
       +
       }:

     

       6
       6
       +
       

     

       7
       7
       +
       stdenvNoCC.mkDerivation rec {

     

       8
       8
       +
         pname = "deepin-gtk-theme";

     

       9
       9
       +
         version = "unstable-2022-07-26";

     

       10
       10
       +
       

     

       11
       11
       +
         src = fetchFromGitHub {

     

       12
       12
       +
           owner = "linuxdeepin";

     

       13
       13
       +
           repo = "deepin-gtk-theme";

     

       14
       14
       +
           rev = "5ac53cbdfba4e6804451605db726876a3be9fb07";

     

       15
       15
       +
           sha256 = "sha256-NJ5URKYs4rVzddXxkwJK9ih40f8McVEbj3G1tPFAiMs";

     

       16
       16
       +
         };

     

       17
       17
       +
       

     

       18
       18
       +
         propagatedUserEnvPkgs = [

     

       19
       19
       +
           gtk-engine-murrine

     

       20
       20
       +
         ];

     

       21
       21
       +
       

     

       22
       22
       +
         makeFlags = [ "PREFIX=${placeholder "out"}" ];

     

       23
       23
       +
       

     

       24
       24
       +
         meta = with lib; {

     

       25
       25
       +
           description = "Deepin GTK Theme";

     

       26
       26
       +
           homepage = "https://github.com/linuxdeepin/deepin-gtk-theme";

     

       27
       27
       +
           license = licenses.gpl3Plus;

     

       28
       28
       +
           platforms = platforms.unix;

     

       29
       29
       +
           maintainers = teams.deepin.members;

     

       30
       30
       +
         };

     

       31
       31
       +
       }

+46

pkgs/desktops/deepin/artwork/deepin-icon-theme/default.nix

···

       1
       1
       +
       { stdenvNoCC

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchFromGitHub

     

       4
       4
       +
       , gtk3

     

       5
       5
       +
       , xcursorgen

     

       6
       6
       +
       , papirus-icon-theme

     

       7
       7
       +
       }:

     

       8
       8
       +
       

     

       9
       9
       +
       stdenvNoCC.mkDerivation rec {

     

       10
       10
       +
         pname = "deepin-icon-theme";

     

       11
       11
       +
         version = "2021.11.24";

     

       12
       12
       +
       

     

       13
       13
       +
         src = fetchFromGitHub {

     

       14
       14
       +
           owner = "linuxdeepin";

     

       15
       15
       +
           repo = pname;

     

       16
       16
       +
           rev = version;

     

       17
       17
       +
           sha256 = "sha256-UC3PbqolcCbVrIEDqMovfJ4oeofMUGJag1A6u7X3Ml8=";

     

       18
       18
       +
         };

     

       19
       19
       +
       

     

       20
       20
       +
         makeFlags = [ "PREFIX=${placeholder "out"}" ];

     

       21
       21
       +
       

     

       22
       22
       +
         nativeBuildInputs = [

     

       23
       23
       +
           gtk3

     

       24
       24
       +
           xcursorgen

     

       25
       25
       +
         ];

     

       26
       26
       +
       

     

       27
       27
       +
         propagatedBuildInputs = [

     

       28
       28
       +
           papirus-icon-theme

     

       29
       29
       +
         ];

     

       30
       30
       +
       

     

       31
       31
       +
         dontDropIconThemeCache = true;

     

       32
       32
       +
       

     

       33
       33
       +
         postFixup = ''

     

       34
       34
       +
           for theme in $out/share/icons/*; do

     

       35
       35
       +
             gtk-update-icon-cache $theme

     

       36
       36
       +
           done

     

       37
       37
       +
         '';

     

       38
       38
       +
       

     

       39
       39
       +
         meta = with lib; {

     

       40
       40
       +
           description = "Deepin Icon Theme provides the base icon themes on Deepin";

     

       41
       41
       +
           homepage = "https://github.com/linuxdeepin/deepin-icon-theme";

     

       42
       42
       +
           license = licenses.gpl3Plus;

     

       43
       43
       +
           platforms = platforms.linux;

     

       44
       44
       +
           maintainers = teams.deepin.members;

     

       45
       45
       +
         };

     

       46
       46
       +
       }

+26

pkgs/desktops/deepin/artwork/deepin-sound-theme/default.nix

···

       1
       1
       +
       { stdenvNoCC

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchFromGitHub

     

       4
       4
       +
       }:

     

       5
       5
       +
       

     

       6
       6
       +
       stdenvNoCC.mkDerivation rec {

     

       7
       7
       +
         pname = "deepin-sound-theme";

     

       8
       8
       +
         version = "15.10.6";

     

       9
       9
       +
       

     

       10
       10
       +
         src = fetchFromGitHub {

     

       11
       11
       +
           owner = "linuxdeepin";

     

       12
       12
       +
           repo = pname;

     

       13
       13
       +
           rev = version;

     

       14
       14
       +
           sha256 = "sha256-BvG/ygZfM6sDuDSzAqwCzDXGT/bbA6Srlpg3br117OU=";

     

       15
       15
       +
         };

     

       16
       16
       +
       

     

       17
       17
       +
         makeFlags = [ "PREFIX=${placeholder "out"}" ];

     

       18
       18
       +
       

     

       19
       19
       +
         meta = with lib; {

     

       20
       20
       +
           description = "The freedesktop sound theme for Deepin";

     

       21
       21
       +
           homepage = "https://github.com/linuxdeepin/deepin-sound-theme";

     

       22
       22
       +
           license = licenses.gpl3Plus;

     

       23
       23
       +
           platforms = platforms.linux;

     

       24
       24
       +
           maintainers = teams.deepin.members;

     

       25
       25
       +
         };

     

       26
       26
       +
       }

+7

pkgs/desktops/deepin/default.nix

···

       22
       22
        
       

     

       23
       23
        
           #### Dtk Application

     

       24
       24
        
           deepin-calculator = callPackage ./apps/deepin-calculator { };

     

       25
       25
       +
           deepin-terminal = callPackage ./apps/deepin-terminal { };

     

       26
       26
       +
       

     

       27
       27
       +
           #### ARTWORK

     

       28
       28
       +
           dde-account-faces = callPackage ./artwork/dde-account-faces { };

     

       29
       29
       +
           deepin-icon-theme = callPackage ./artwork/deepin-icon-theme { };

     

       30
       30
       +
           deepin-gtk-theme = callPackage ./artwork/deepin-gtk-theme { };

     

       31
       31
       +
           deepin-sound-theme = callPackage ./artwork/deepin-sound-theme { };

     

       25
       32
        
         };

     

       26
       33
        
       in

     

       27
       34
        
       lib.makeScope libsForQt5.newScope packages

+2 -2

pkgs/desktops/pantheon/third-party/pantheon-tweaks/default.nix

···

       14
       14
        
       

     

       15
       15
        
       stdenv.mkDerivation rec {

     

       16
       16
        
         pname = "pantheon-tweaks";

     

       17
       17
       -
         version = "1.0.4";

     

       17
       17
       +
         version = "1.1.0";

     

       18
       18
        
       

     

       19
       19
        
         src = fetchFromGitHub {

     

       20
       20
        
           owner = "pantheon-tweaks";

     

       21
       21
        
           repo = pname;

     

       22
       22
        
           rev = version;

     

       23
       23
       -
           sha256 = "sha256-L/3PrkfWOGYtqeH/DajGEGCsF5yYnWuESxUTfROSHQ4=";

     

       23
       23
       +
           sha256 = "sha256-wj9bvcES8JAgDtW0Damfd8VQNLK+SCFTDVWp/nYGcgI=";

     

       24
       24
        
         };

     

       25
       25
        
       

     

       26
       26
        
         patches = [

+21 -3

pkgs/desktops/xfce/applications/xfce4-taskmanager/default.nix

···

       1
       1
       -
       { lib, mkXfceDerivation, exo, gtk3, libxfce4ui, xfconf, libwnck, libXmu }:

     

       1
       1
       +
       { lib

     

       2
       2
       +
       , mkXfceDerivation

     

       3
       3
       +
       , exo

     

       4
       4
       +
       , gtk3

     

       5
       5
       +
       , libxfce4ui

     

       6
       6
       +
       , xfconf

     

       7
       7
       +
       , libwnck

     

       8
       8
       +
       , libXmu

     

       9
       9
       +
       }:

     

       2
       10
        
       

     

       3
       11
        
       mkXfceDerivation {

     

       4
       12
        
         category = "apps";

     

       5
       13
        
         pname = "xfce4-taskmanager";

     

       6
       14
        
         version = "1.5.5";

     

       15
       15
       +
         odd-unstable = false;

     

       7
       16
        
       

     

       8
       17
        
         sha256 = "sha256-worHYB9qibRxMaCYQ0+nHA9CSTColewgahyrXiPOnQA=";

     

       9
       18
        
       

     

       10
       10
       -
         nativeBuildInputs = [ exo ];

     

       11
       11
       -
         buildInputs = [ gtk3 libxfce4ui xfconf libwnck libXmu ];

     

       19
       19
       +
         nativeBuildInputs = [

     

       20
       20
       +
           exo

     

       21
       21
       +
         ];

     

       22
       22
       +
       

     

       23
       23
       +
         buildInputs = [

     

       24
       24
       +
           gtk3

     

       25
       25
       +
           libxfce4ui

     

       26
       26
       +
           xfconf

     

       27
       27
       +
           libwnck

     

       28
       28
       +
           libXmu

     

       29
       29
       +
         ];

     

       12
       30
        
       

     

       13
       31
        
         meta = with lib; {

     

       14
       32
        
           description = "Easy to use task manager for Xfce";

+2 -2

pkgs/desktops/xfce/core/libxfce4util/default.nix

···

       3
       3
        
       mkXfceDerivation {

     

       4
       4
        
         category = "xfce";

     

       5
       5
        
         pname = "libxfce4util";

     

       6
       6
       -
         version = "4.18.0";

     

       6
       6
       +
         version = "4.18.1";

     

       7
       7
        
       

     

       8
       8
       -
         sha256 = "sha256-m4O/vTFqzkF6rzyGVw8xdwcX7S/SyOSJo8aCZjniXAw=";

     

       8
       8
       +
         sha256 = "sha256-nqASXyHR7wNiNPorlz2ix+Otyir6I9KCCr1vfS6GO8E=";

     

       9
       9
        
       

     

       10
       10
        
         nativeBuildInputs = [ gobject-introspection vala ];

     

       11
       11

+2 -2

pkgs/desktops/xfce/core/thunar/default.nix

···

       21
       21
        
       let unwrapped = mkXfceDerivation {

     

       22
       22
        
         category = "xfce";

     

       23
       23
        
         pname = "thunar";

     

       24
       24
       -
         version = "4.18.1";

     

       24
       24
       +
         version = "4.18.3";

     

       25
       25
        
       

     

       26
       26
       -
         sha256 = "sha256-n624TZGygFrOjkQ9fUVJUetRV8JDXYSg89tOHm4Va+M=";

     

       26
       26
       +
         sha256 = "sha256-sYn1gBzqEFcB3jHWxmoqqv0Cxa3mui/j0kgBqJMgJrc=";

     

       27
       27
        
       

     

       28
       28
        
         nativeBuildInputs = [

     

       29
       29
        
           docbook_xsl

+2 -7

pkgs/desktops/xfce/core/xfce4-panel/default.nix

···

       2
       2
        
       , mkXfceDerivation

     

       3
       3
        
       , exo

     

       4
       4
        
       , garcon

     

       5
       5
       -
       , glib

     

       6
       5
        
       , gobject-introspection

     

       7
       6
        
       , gtk3

     

       8
       7
        
       , libdbusmenu-gtk3

     
···

       17
       16
        
       mkXfceDerivation {

     

       18
       17
        
         category = "xfce";

     

       19
       18
        
         pname = "xfce4-panel";

     

       20
       20
       -
         version = "4.18.0";

     

       19
       19
       +
         version = "4.18.1";

     

       21
       20
        
       

     

       22
       22
       -
         sha256 = "sha256-CnZk0Ca3IG6nmiwe7eIvPqpzJgRZHIyqeoTA5cPpU7s=";

     

       21
       21
       +
         sha256 = "sha256-5GJO8buOTnRGnm3+kesrZjTprCY1qiyookpW6dzI2AE=";

     

       23
       22
        
       

     

       24
       23
        
         nativeBuildInputs = [

     

       25
       24
        
           gobject-introspection

     
···

       37
       36
        
         ];

     

       38
       37
        
       

     

       39
       38
        
         propagatedBuildInputs = [

     

       40
       40
       -
           glib

     

       41
       39
        
           gtk3

     

       42
       40
        
           libxfce4util

     

       43
       41
        
         ];

     
···

       48
       46
        
           substituteInPlace plugins/clock/clock.c \

     

       49
       47
        
              --replace "/usr/share/zoneinfo" "${tzdata}/share/zoneinfo"

     

       50
       48
        
         '';

     

       51
       51
       -
       

     

       52
       52
       -
         # Workaround https://bugzilla.xfce.org/show_bug.cgi?id=15825

     

       53
       53
       -
         NIX_CFLAGS_COMPILE = "-I${glib.dev}/include/gio-unix-2.0";

     

       54
       49
        
       

     

       55
       50
        
         meta = with lib; {

     

       56
       51
        
           description = "Panel for the Xfce desktop environment";

+2 -2

pkgs/desktops/xfce/core/xfdesktop/default.nix

···

       3
       3
        
       mkXfceDerivation {

     

       4
       4
        
         category = "xfce";

     

       5
       5
        
         pname = "xfdesktop";

     

       6
       6
       -
         version = "4.18.0";

     

       6
       6
       +
         version = "4.18.1";

     

       7
       7
        
       

     

       8
       8
       -
         sha256 = "sha256-HZVu5UVLKDCWaUpw1SV8E0JLGRG946w4QLlA51rg/Bo=";

     

       8
       8
       +
         sha256 = "sha256-33G7X5kA3MCNJ9Aq9ZCafP0Qm/46iUmLFB8clhKwDz8=";

     

       9
       9
        
       

     

       10
       10
        
         buildInputs = [

     

       11
       11
        
           exo

+2 -2

pkgs/desktops/xfce/panel-plugins/xfce4-datetime-plugin/default.nix

···

       9
       9
        
       mkXfceDerivation {

     

       10
       10
        
         category = "panel-plugins";

     

       11
       11
        
         pname = "xfce4-datetime-plugin";

     

       12
       12
       -
         version = "0.8.2";

     

       12
       12
       +
         version = "0.8.3";

     

       13
       13
        
       

     

       14
       14
        
         rev-prefix = "xfce4-datetime-plugin-";

     

       15
       15
       -
         sha256 = "sha256-ov4Wh9Pj01u0NrjDn5p+qXlD2LY3gEUC1e/jPjkn4xQ=";

     

       15
       15
       +
         sha256 = "sha256-dpN5ZN7VjgO1GQ6v8NXuBKACyIwIosaiVGtmLEb6auI=";

     

       16
       16
        
       

     

       17
       17
        
         nativeBuildInputs = [

     

       18
       18
        
           gettext

+2 -2

pkgs/desktops/xfce/panel-plugins/xfce4-whiskermenu-plugin/default.nix

···

       3
       3
        
       mkXfceDerivation {

     

       4
       4
        
         category = "panel-plugins";

     

       5
       5
        
         pname = "xfce4-whiskermenu-plugin";

     

       6
       6
       -
         version = "2.7.1";

     

       6
       6
       +
         version = "2.7.2";

     

       7
       7
        
         rev-prefix = "v";

     

       8
       8
        
         odd-unstable = false;

     

       9
       9
       -
         sha256 = "sha256-aN8PwH5YIbjiyS5tTcU2AU4LAYC2tBStDxhCXi/dvkQ=";

     

       9
       9
       +
         sha256 = "sha256-yp8NpBVgqEv34qmDMKPdy53awgSLtYfeaw1JrxENFps=";

     

       10
       10
        
       

     

       11
       11
        
         nativeBuildInputs = [ cmake ];

     

       12
       12

+1 -1

pkgs/development/compilers/gcc/common/configure-flags.nix

···

       119
       119
        
             #  or ${with_sysroot}${native_system_header_dir}

     

       120
       120
        
             # While native build (build == host == target) uses passed headers

     

       121
       121
        
             # path as is:

     

       122
       122
       -
             #    ${native_system_header_dir}

     

       122
       122
       +
             #    ${with_build_sysroot}${native_system_header_dir}

     

       123
       123
        
             #

     

       124
       124
        
             # Nixpkgs uses flat directory structure for both native and cross

     

       125
       125
        
             # cases. As a result libc headers don't get found for cross case

+69

pkgs/development/compilers/zig/0.10.nix

···

       1
       1
       +
       { lib

     

       2
       2
       +
       , stdenv

     

       3
       3
       +
       , fetchFromGitHub

     

       4
       4
       +
       , cmake

     

       5
       5
       +
       , coreutils

     

       6
       6
       +
       , llvmPackages

     

       7
       7
       +
       , libxml2

     

       8
       8
       +
       , zlib

     

       9
       9
       +
       }:

     

       10
       10
       +
       

     

       11
       11
       +
       stdenv.mkDerivation rec {

     

       12
       12
       +
         pname = "zig";

     

       13
       13
       +
         version = "0.10.1";

     

       14
       14
       +
       

     

       15
       15
       +
         src = fetchFromGitHub {

     

       16
       16
       +
           owner = "ziglang";

     

       17
       17
       +
           repo = pname;

     

       18
       18
       +
           rev = version;

     

       19
       19
       +
           hash = "sha256-69QIkkKzApOGfrBdgtmxFMDytRkSh+0YiaJQPbXsBeo=";

     

       20
       20
       +
         };

     

       21
       21
       +
       

     

       22
       22
       +
         nativeBuildInputs = [

     

       23
       23
       +
           cmake

     

       24
       24
       +
           llvmPackages.llvm.dev

     

       25
       25
       +
         ];

     

       26
       26
       +
       

     

       27
       27
       +
         buildInputs = [

     

       28
       28
       +
           coreutils

     

       29
       29
       +
           libxml2

     

       30
       30
       +
           zlib

     

       31
       31
       +
         ] ++ (with llvmPackages; [

     

       32
       32
       +
           libclang

     

       33
       33
       +
           lld

     

       34
       34
       +
           llvm

     

       35
       35
       +
         ]);

     

       36
       36
       +
       

     

       37
       37
       +
         preBuild = ''

     

       38
       38
       +
           export HOME=$TMPDIR;

     

       39
       39
       +
         '';

     

       40
       40
       +
       

     

       41
       41
       +
         postPatch = ''

     

       42
       42
       +
           # Zig's build looks at /usr/bin/env to find dynamic linking info. This

     

       43
       43
       +
           # doesn't work in Nix' sandbox. Use env from our coreutils instead.

     

       44
       44
       +
           substituteInPlace lib/std/zig/system/NativeTargetInfo.zig --replace "/usr/bin/env" "${coreutils}/bin/env"

     

       45
       45
       +
         '';

     

       46
       46
       +
       

     

       47
       47
       +
         cmakeFlags = [

     

       48
       48
       +
           # file RPATH_CHANGE could not write new RPATH

     

       49
       49
       +
           "-DCMAKE_SKIP_BUILD_RPATH=ON"

     

       50
       50
       +
         ];

     

       51
       51
       +
       

     

       52
       52
       +
         doCheck = true;

     

       53
       53
       +
         installCheckPhase = ''

     

       54
       54
       +
           $out/bin/zig test --cache-dir "$TMPDIR" -I $src/test $src/test/behavior.zig

     

       55
       55
       +
         '';

     

       56
       56
       +
       

     

       57
       57
       +
         meta = with lib; {

     

       58
       58
       +
           homepage = "https://ziglang.org/";

     

       59
       59
       +
           description =

     

       60
       60
       +
             "General-purpose programming language and toolchain for maintaining robust, optimal, and reusable software";

     

       61
       61
       +
           license = licenses.mit;

     

       62
       62
       +
           maintainers = with maintainers; [ aiotter andrewrk AndersonTorres ];

     

       63
       63
       +
           platforms = platforms.unix;

     

       64
       64
       +
           # Build fails on Darwin on both AArch64 and x86_64:

     

       65
       65
       +
           # https://github.com/NixOS/nixpkgs/pull/210324#issuecomment-1381313616

     

       66
       66
       +
           # https://github.com/NixOS/nixpkgs/pull/210324#issuecomment-1381236045

     

       67
       67
       +
           broken = stdenv.isDarwin;

     

       68
       68
       +
         };

     

       69
       69
       +
       }

pkgs/development/compilers/zig/default.nix pkgs/development/compilers/zig/0.9.1.nix

+3

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

···

       6
       6
        
         repo = "Coq-Equations";

     

       7
       7
        
         inherit version;

     

       8
       8
        
         defaultVersion = lib.switch coq.coq-version [

     

       9
       9
       +
           { case = "8.17"; out = "1.3+8.17"; }

     

       9
       10
        
           { case = "8.16"; out = "1.3+8.16"; }

     

       10
       11
        
           { case = "8.15"; out = "1.3+8.15"; }

     

       11
       12
        
           { case = "8.14"; out = "1.3+8.14"; }

     
···

       54
       55
        
           release."1.3+8.15".sha256         = "1vfcfpsp9zyj0sw0cwibk76nj6n0r6gwh8m1aa3lbvc0b1kbm32k";

     

       55
       56
        
           release."1.3+8.16".rev            = "v1.3-8.16";

     

       56
       57
        
           release."1.3+8.16".sha256         = "sha256-zyMGeRObtSGWh7n3WCqesBZL5EgLvKwmnTy09rYpxyE=";

     

       58
       58
       +
           release."1.3+8.17".rev            = "v1.3-8.17";

     

       59
       59
       +
           release."1.3+8.17".sha256         = "sha256-yNotSIxFkhTg3reZIchGQ7cV9WmTJ7p7hPfKGBiByDw=";

     

       57
       60
        
       

     

       58
       61
        
         mlPlugin = true;

     

       59
       62

+2 -2

pkgs/development/interpreters/erlang/R25.nix

···

       1
       1
        
       { mkDerivation }:

     

       2
       2
        
       

     

       3
       3
        
       mkDerivation {

     

       4
       4
       -
         version = "25.2.1";

     

       5
       5
       -
         sha256 = "xJ3fadveOFZ0TeHhjl3VnAtWyFTOVUIoFubXofvrsT0=";

     

       4
       4
       +
         version = "25.2.2";

     

       5
       5
       +
         sha256 = "HfEh2IhifFe/gQ4sK99uBnmUGvNCeJ2mlTQf7IzenEs=";

     

       6
       6
        
       }

+4 -4

pkgs/development/interpreters/wasmer/default.nix

···

       14
       14
        
       

     

       15
       15
        
       rustPlatform.buildRustPackage rec {

     

       16
       16
        
         pname = "wasmer";

     

       17
       17
       -
         version = "3.1.0";

     

       17
       17
       +
         version = "3.1.1";

     

       18
       18
        
       

     

       19
       19
        
         src = fetchFromGitHub {

     

       20
       20
        
           owner = "wasmerio";

     

       21
       21
        
           repo = pname;

     

       22
       22
       -
           rev = "v${version}";

     

       23
       23
       -
           sha256 = "sha256-t/ObsvUSNGFvHkVH2nl8vLFI+5GUQx6niCgeH4ykk/0=";

     

       22
       22
       +
           rev = "refs/tags/v${version}";

     

       23
       23
       +
           hash = "sha256-797I3FBBfnAgNfOdMajm3WNkMo3MUXb1347LBggXrLk=";

     

       24
       24
        
         };

     

       25
       25
        
       

     

       26
       26
       -
         cargoSha256 = "sha256-75/0D0lrV50wH51Ll7M1Lvqj2kRSaJXiQWElxCaF9mE=";

     

       26
       26
       +
         cargoHash = "sha256-zUTwhfRLKUixgj3JXiz2QOuwbFhfget+GcFSRL1QJ3w=";

     

       27
       27
        
       

     

       28
       28
        
         nativeBuildInputs = [ rustPlatform.bindgenHook ];

     

       29
       29

+2 -2

pkgs/development/libraries/cmark-gfm/default.nix

···

       1
       1
        
       { lib, stdenv, fetchFromGitHub, cmake }:

     

       2
       2
        
       stdenv.mkDerivation rec {

     

       3
       3
        
         pname = "cmark-gfm";

     

       4
       4
       -
         version = "0.29.0.gfm.8";

     

       4
       4
       +
         version = "0.29.0.gfm.9";

     

       5
       5
        
       

     

       6
       6
        
         src = fetchFromGitHub {

     

       7
       7
        
           owner = "github";

     

       8
       8
        
           repo = "cmark-gfm";

     

       9
       9
        
           rev = version;

     

       10
       10
       -
           sha256 = "sha256-i+y1VORza6pn8a/AfbBKpov/n0ChR9++RC7E8P9p3MY=";

     

       10
       10
       +
           sha256 = "sha256-goQtLaiLCyEqVItPfH3e/pFroQWZuVT5oxLs1/GwdoU=";

     

       11
       11
        
         };

     

       12
       12
        
       

     

       13
       13
        
         nativeBuildInputs = [ cmake ];

+7 -3

pkgs/development/libraries/dqlite/default.nix

···

       1
       1
        
       { lib, stdenv, fetchFromGitHub, autoreconfHook, pkg-config, file, libuv

     

       2
       2
       -
       , raft-canonical, sqlite }:

     

       2
       2
       +
       , raft-canonical, sqlite, lxd }:

     

       3
       3
        
       

     

       4
       4
        
       stdenv.mkDerivation rec {

     

       5
       5
        
         pname = "dqlite";

     

       6
       6
       -
         version = "1.13.0";

     

       6
       6
       +
         version = "1.14.0";

     

       7
       7
        
       

     

       8
       8
        
         src = fetchFromGitHub {

     

       9
       9
        
           owner = "canonical";

     

       10
       10
        
           repo = pname;

     

       11
       11
        
           rev = "refs/tags/v${version}";

     

       12
       12
       -
           hash = "sha256-KVQa11gw/8h3Be+52V44W2M+fd7sB35emrS/aUEUGl0=";

     

       12
       12
       +
           hash = "sha256-x76f9Sw3BMgWSY7DLIqDjbggp/qVu8mJBtf4znTz9hA=";

     

       13
       13
        
         };

     

       14
       14
        
       

     

       15
       15
        
         nativeBuildInputs = [ autoreconfHook file pkg-config ];

     
···

       25
       25
        
         doCheck = false;

     

       26
       26
        
       

     

       27
       27
        
         outputs = [ "dev" "out" ];

     

       28
       28
       +
       

     

       29
       29
       +
         passthru.tests = {

     

       30
       30
       +
           inherit lxd;

     

       31
       31
       +
         };

     

       28
       32
        
       

     

       29
       33
        
         meta = with lib; {

     

       30
       34
        
           description = ''

+2 -2

pkgs/development/libraries/gdcm/default.nix

···

       13
       13
        
       

     

       14
       14
        
       stdenv.mkDerivation rec {

     

       15
       15
        
         pname = "gdcm";

     

       16
       16
       -
         version = "3.0.20";

     

       16
       16
       +
         version = "3.0.21";

     

       17
       17
        
       

     

       18
       18
        
         src = fetchFromGitHub {

     

       19
       19
        
           owner = "malaterre";

     

       20
       20
        
           repo = "GDCM";

     

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

     

       22
       22
       -
           sha256 = "sha256-MaQk2VlaZxZPNzVF9pUnEzMaXyN0tq2P3kodnGpl6PA=";

     

       22
       22
       +
           sha256 = "sha256-BmUJCqCGt+BvVpLG4bzCH4lsqmhWHU0gbOIU2CCIMGU=";

     

       23
       23
        
         };

     

       24
       24
        
       

     

       25
       25
        
         cmakeFlags = [

+2 -2

pkgs/development/libraries/goffice/default.nix

···

       3
       3
        
       

     

       4
       4
        
       stdenv.mkDerivation rec {

     

       5
       5
        
         pname = "goffice";

     

       6
       6
       -
         version = "0.10.53";

     

       6
       6
       +
         version = "0.10.54";

     

       7
       7
        
       

     

       8
       8
        
         outputs = [ "out" "dev" "devdoc" ];

     

       9
       9
        
       

     

       10
       10
        
         src = fetchurl {

     

       11
       11
        
           url = "mirror://gnome/sources/${pname}/${lib.versions.majorMinor version}/${pname}-${version}.tar.xz";

     

       12
       12
       -
           sha256 = "J/1YeW+qHNTMASDDTqhTFaCJHscfVbxnk8FOzxaKP1c=";

     

       12
       12
       +
           sha256 = "WDXNnVPmT3UmLAOZZu/fTYj0Vvyx8IeM5NEIgqUK1aA=";

     

       13
       13
        
         };

     

       14
       14
        
       

     

       15
       15
        
         nativeBuildInputs = [ pkg-config intltool ];

+2 -2

pkgs/development/libraries/jellyfin-ffmpeg/default.nix

···

       9
       9
        
         nv-codec-headers = nv-codec-headers-11;

     

       10
       10
        
       }).overrideAttrs (old: rec {

     

       11
       11
        
         pname = "jellyfin-ffmpeg";

     

       12
       12
       -
         version = "5.1.2-6";

     

       12
       12
       +
         version = "5.1.2-7";

     

       13
       13
        
       

     

       14
       14
        
         src = fetchFromGitHub {

     

       15
       15
        
           owner = "jellyfin";

     

       16
       16
        
           repo = "jellyfin-ffmpeg";

     

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

     

       18
       18
       -
           sha256 = "sha256-YPw29cnScchL4Y2CEatUjzqUW/U9kOdi29Dr577Qy5A=";

     

       18
       18
       +
           sha256 = "sha256-OWSixz1QjWthykO55wMAlywe2ihFLugzLH1qg4Qbe3I=";

     

       19
       19
        
         };

     

       20
       20
        
       

     

       21
       21
        
         buildInputs = old.buildInputs ++ [ chromaprint ];

+2 -2

pkgs/development/libraries/libffcall/default.nix

···

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation rec {

     

       4
       4
        
         pname = "libffcall";

     

       5
       5
       -
         version = "2.2";

     

       5
       5
       +
         version = "2.4";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchurl {

     

       8
       8
        
           url = "mirror://gnu/libffcall/libffcall-${version}.tar.gz";

     

       9
       9
       -
           sha256 = "sha256-6/o3+XtslPrCTs8xk/n8gpUXz4Gu6awtGRr5k9c8t0c=";

     

       9
       9
       +
           sha256 = "sha256-jvaZIdvcBrxbuQUTYiY3p7g6cfMfW6N3vp2P2PV5EsI=";

     

       10
       10
        
         };

     

       11
       11
        
       

     

       12
       12
        
         enableParallelBuilding = false;

+2 -2

pkgs/development/libraries/live555/default.nix

···

       10
       10
        
       

     

       11
       11
        
       stdenv.mkDerivation rec {

     

       12
       12
        
         pname = "live555";

     

       13
       13
       -
         version = "2022.12.01";

     

       13
       13
       +
         version = "2023.01.19";

     

       14
       14
        
       

     

       15
       15
        
         src = fetchurl {

     

       16
       16
        
           urls = [

     
···

       18
       18
        
             "https://download.videolan.org/contrib/live555/live.${version}.tar.gz"

     

       19
       19
        
             "mirror://sourceforge/slackbuildsdirectlinks/live.${version}.tar.gz"

     

       20
       20
        
           ];

     

       21
       21
       -
           sha256 = "sha256-BXwdPcJMJrM+FMTcNZKIWt8iBAOh4SVeihAeIzxpwQg=";

     

       21
       21
       +
           sha256 = "sha256-p8ZJE/f3AHxf3CnqgR48p4HyYicbPkKv3UvBBB2G+pk=";

     

       22
       22
        
         };

     

       23
       23
        
       

     

       24
       24
        
         nativeBuildInputs = lib.optional stdenv.isDarwin darwin.cctools;

+9 -1

pkgs/development/libraries/openmpi/default.nix

···

       1
       1
       -
       { lib, stdenv, fetchurl, gfortran, perl, libnl

     

       1
       1
       +
       { lib, stdenv, fetchurl, fetchpatch, gfortran, perl, libnl

     

       2
       2
        
       , rdma-core, zlib, numactl, libevent, hwloc, targetPackages, symlinkJoin

     

       3
       3
        
       , libpsm2, libfabric, pmix, ucx

     

       4
       4
        
       

     
···

       31
       31
        
           url = "https://www.open-mpi.org/software/ompi/v${major version}.${minor version}/downloads/${pname}-${version}.tar.bz2";

     

       32
       32
        
           sha256 = "03ckngrff1cl0l81vfvrfhp99rbgk7s0633kr1l468yibwbjx4cj";

     

       33
       33
        
         };

     

       34
       34
       +
       

     

       35
       35
       +
         patches = [

     

       36
       36
       +
           (fetchpatch {

     

       37
       37
       +
             name = "RDMA-osc-perform-CAS-in-shared-memory-if-possible.patch";

     

       38
       38
       +
             url = "https://github.com/open-mpi/ompi/pull/10513/commits/0512c135a77a0278e5288e0e119dce24c95ebed4.patch";

     

       39
       39
       +
             sha256 = "sha256-K1Gc+hBUkTPY1WqLP6JWo623EUhkoL4ONrqPVDNfFuE=";

     

       40
       40
       +
           })

     

       41
       41
       +
         ];

     

       34
       42
        
       

     

       35
       43
        
         postPatch = ''

     

       36
       44
        
           patchShebangs ./

+2 -2

pkgs/development/libraries/pinocchio/default.nix

···

       11
       11
        
       

     

       12
       12
        
       stdenv.mkDerivation rec {

     

       13
       13
        
         pname = "pinocchio";

     

       14
       14
       -
         version = "2.6.14";

     

       14
       14
       +
         version = "2.6.15";

     

       15
       15
        
       

     

       16
       16
        
         src = fetchFromGitHub {

     

       17
       17
        
           owner = "stack-of-tasks";

     

       18
       18
        
           repo = pname;

     

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

     

       20
       20
        
           fetchSubmodules = true;

     

       21
       21
       -
           sha256 = "sha256-3dPGeWnIVIErLnd+mxwudTj4qHyN2k7H94EsHYmKV1I=";

     

       21
       21
       +
           hash = "sha256-bnm5nbb0mKw76k2J2Qi04n7bmfzadtqV/AmnWSzbb+0=";

     

       22
       22
        
         };

     

       23
       23
        
       

     

       24
       24
        
         # error: use of undeclared identifier '__sincos'

+7 -3

pkgs/development/libraries/raft-canonical/default.nix

···

       1
       1
       -
       { lib, stdenv, fetchFromGitHub, autoreconfHook, pkg-config, file, libuv, lz4 }:

     

       1
       1
       +
       { lib, stdenv, fetchFromGitHub, autoreconfHook, pkg-config, file, libuv, lz4, lxd }:

     

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation rec {

     

       4
       4
        
         pname = "raft-canonical";

     

       5
       5
       -
         version = "0.16.0";

     

       5
       5
       +
         version = "0.17.1";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "canonical";

     

       9
       9
        
           repo = "raft";

     

       10
       10
        
           rev = "refs/tags/v${version}";

     

       11
       11
       -
           hash = "sha256-qDLAEhknY+BB83OC6tfi7w/ZY/K492J5ZglLNUoBwbc=";

     

       11
       11
       +
           hash = "sha256-P6IYl6xcsqXw1ilt6HYw757FL2syy1XePBVGbPAlz6Q=";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         nativeBuildInputs = [ autoreconfHook file pkg-config ];

     
···

       31
       31
        
         doCheck = true;

     

       32
       32
        
       

     

       33
       33
        
         outputs = [ "dev" "out" ];

     

       34
       34
       +
       

     

       35
       35
       +
         passthru.tests = {

     

       36
       36
       +
           inherit lxd;

     

       37
       37
       +
         };

     

       34
       38
        
       

     

       35
       39
        
         meta = with lib; {

     

       36
       40
        
           description = ''

+2 -2

pkgs/development/libraries/umockdev/default.nix

···

       20
       20
        
       

     

       21
       21
        
       stdenv.mkDerivation rec {

     

       22
       22
        
         pname = "umockdev";

     

       23
       23
       -
         version = "0.17.15";

     

       23
       23
       +
         version = "0.17.16";

     

       24
       24
        
       

     

       25
       25
        
         outputs = [ "bin" "out" "dev" "devdoc" ];

     

       26
       26
        
       

     

       27
       27
        
         src = fetchurl {

     

       28
       28
        
           url = "https://github.com/martinpitt/umockdev/releases/download/${version}/${pname}-${version}.tar.xz";

     

       29
       29
       -
           sha256 = "7UGO4rv7B4H0skuXKe8nCtg83czWaln/lEsFnvE2j+8=";

     

       29
       29
       +
           sha256 = "sha256-T0BbjOkhn4EX2GBezYFbiUHNgp2uEbSiaxpJ/36jriY=";

     

       30
       30
        
         };

     

       31
       31
        
       

     

       32
       32
        
         patches = [

+13 -20

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

···

       1
       1
       -
       { lib, fetchFromGitHub, buildDunePackage, pkg-config, dune-configurator, stdio, R

     

       1
       1
       +
       { lib, fetchFromGitHub, fetchpatch, buildDunePackage, pkg-config, dune-configurator, stdio, R

     

       2
       2
        
       , alcotest

     

       3
       3
        
       }:

     

       4
       4
        
       

     

       5
       5
        
       buildDunePackage rec {

     

       6
       6
        
         pname = "ocaml-r";

     

       7
       7
       -
         version = "0.4.0";

     

       7
       7
       +
         version = "0.6.0";

     

       8
       8
        
       

     

       9
       9
       -
         useDune2 = true;

     

       9
       9
       +
         duneVersion = "3";

     

       10
       10
        
       

     

       11
       11
       -
         minimumOCamlVersion = "4.08";

     

       11
       11
       +
         minimalOCamlVersion = "4.08";

     

       12
       12
        
       

     

       13
       13
        
         src = fetchFromGitHub {

     

       14
       14
        
           owner = "pveber";

     

       15
       15
        
           repo = pname;

     

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

     

       17
       17
       -
           sha256 = "10is2s148kfh3g0pwniyzp5mh48k57ldvn8gm86469zvgxyij1ri";

     

       17
       17
       +
           sha256 = "sha256-jPyVMxjeh9+xu0dD1gelAxcOhxouKczyvzVoKZ5oSrs=";

     

       18
       18
        
         };

     

       19
       19
        
       

     

       20
       20
       -
         # Without the following patch, stub generation fails with:

     

       21
       21
       -
         # > Fatal error: exception (Failure "not supported: osVersion")

     

       22
       22
       -
         preConfigure = ''

     

       23
       23
       -
           substituteInPlace stubgen/stubgen.ml --replace  \

     

       24
       24
       -
           'failwithf "not supported: %s" name ()' \

     

       25
       25
       -
           'sprintf "(* not supported: %s *)" name'

     

       26
       26
       -
           substituteInPlace lib/config/discover.ml --replace \

     

       27
       27
       -
           ' libRmath"' '"'

     

       28
       28
       -
         '';

     

       29
       29
       -
       

     

       30
       30
       -
         # This currently fails with dune

     

       31
       31
       -
         strictDeps = false;

     

       20
       20
       +
         # Finds R and Rmathlib separatley

     

       21
       21
       +
         patches = [

     

       22
       22
       +
           (fetchpatch {

     

       23
       23
       +
             url = "https://github.com/pveber/ocaml-r/commit/aa96dc5.patch";

     

       24
       24
       +
             sha256 = "sha256-xW33W2ciesyUkDKEH08yfOXv0wP0V6X80or2/n2Nrb4=";

     

       25
       25
       +
           })

     

       26
       26
       +
         ];

     

       32
       27
        
       

     

       33
       28
        
         nativeBuildInputs = [ pkg-config R ];

     

       34
       29
        
         buildInputs = [ dune-configurator stdio R ];

     

       35
       30
        
       

     

       36
       31
        
         doCheck = true;

     

       37
       37
       -
         nativeCheckInputs = [ alcotest ];

     

       32
       32
       +
         checkInputs = [ alcotest ];

     

       38
       33
        
       

     

       39
       34
        
         meta = {

     

       40
       40
       -
           # This has been broken by the update to R 4.2.0 (#171597)

     

       41
       41
       -
           broken = true;

     

       42
       35
        
           description = "OCaml bindings for the R interpreter";

     

       43
       36
        
           inherit (src.meta) homepage;

     

       44
       37
        
           license = lib.licenses.gpl3;

+2 -2

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

···

       8
       8
        
       

     

       9
       9
        
       buildPythonPackage rec {

     

       10
       10
        
         pname = "ailment";

     

       11
       11
       -
         version = "9.2.35";

     

       11
       11
       +
         version = "9.2.36";

     

       12
       12
        
         format = "pyproject";

     

       13
       13
        
       

     

       14
       14
        
         disabled = pythonOlder "3.8";

     
···

       17
       17
        
           owner = "angr";

     

       18
       18
        
           repo = pname;

     

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

     

       20
       20
       -
           hash = "sha256-t4t9TATmskvi/Qr9Eje7l+tRiKa+NiwI+KVYqEiSNgo=";

     

       20
       20
       +
           hash = "sha256-PEX2SanglMqjtJHuH+gA5dnikh7qqLFiXbmrcIzs1+A=";

     

       21
       21
        
         };

     

       22
       22
        
       

     

       23
       23
        
         nativeBuildInputs = [

+3 -13

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

···

       1
       1
        
       { lib

     

       2
       2
        
       , buildPythonPackage

     

       3
       3
        
       , fetchFromGitHub

     

       4
       4
       -
       , fetchpatch

     

       5
       4
        
       , numpy

     

       6
       5
        
       , pythonOlder

     

       7
       6
        
       }:

     

       8
       7
        
       

     

       9
       8
        
       buildPythonPackage rec {

     

       10
       9
        
         pname = "airtouch4pyapi";

     

       11
       11
       -
         version = "1.0.5";

     

       10
       10
       +
         version = "1.0.8";

     

       12
       11
        
         format = "setuptools";

     

       13
       12
        
       

     

       14
       13
        
         disabled = pythonOlder "3.6";

     
···

       16
       15
        
         src = fetchFromGitHub {

     

       17
       16
        
           owner = "LonePurpleWolf";

     

       18
       17
        
           repo = pname;

     

       19
       19
       -
           # https://github.com/LonePurpleWolf/airtouch4pyapi/issues/5

     

       20
       20
       -
           rev = "34783888846783c058fe79cec16feda45504f701";

     

       21
       21
       -
           sha256 = "17c7fm72p085pg9msvsfdggbskvm12a6jlb5bw1cndrqsqcrxywx";

     

       18
       18
       +
           rev = "refs/tags/v${version}";

     

       19
       19
       +
           hash = "sha256-RiRwebumidn0nijL/e9J74ZYx0DASi1up5BTNxYoGEA=";

     

       22
       20
        
         };

     

       23
       23
       -
       

     

       24
       24
       -
         patches = [

     

       25
       25
       -
           # https://github.com/LonePurpleWolf/airtouch4pyapi/pull/10

     

       26
       26
       -
           (fetchpatch {

     

       27
       27
       -
             url = "https://github.com/LonePurpleWolf/airtouch4pyapi/commit/5b5d91fad63495c83422e7a850897946ac95b25d.patch";

     

       28
       28
       -
             hash = "sha256-tVlCLXuOJSqjbs0jj0iHCIXWZE8wmMV3ChzmE6uq3SM=";

     

       29
       29
       -
           })

     

       30
       30
       -
         ];

     

       31
       21
        
       

     

       32
       22
        
         propagatedBuildInputs = [

     

       33
       23
        
           numpy

+5

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

···

       47
       47
        
             url = "https://github.com/amaranth-lang/amaranth/pull/722/commits/e5a56b07c568e5f4cc2603eefebd14c5cc4e13d8.patch";

     

       48
       48
        
             hash = "sha256-C8FyMSKHA7XsEMpO9eYNZx/X5rGaK7p3eXP+jSb6wVg=";

     

       49
       49
        
           })

     

       50
       50
       +
           (fetchpatch {

     

       51
       51
       +
             name = "add-python-3.11-support.patch";

     

       52
       52
       +
             url = "https://github.com/amaranth-lang/amaranth/commit/851546bf2d16db62663d7002bece51f07078d0a5.patch";

     

       53
       53
       +
             hash = "sha256-eetlFCLqmpCfTKViD16OScJbkql1yhdi5uJGnfnpcCE=";

     

       54
       54
       +
           })

     

       50
       55
        
         ];

     

       51
       56
        
       

     

       52
       57
        
         SETUPTOOLS_SCM_PRETEND_VERSION="${realVersion}";

+2 -2

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

···

       31
       31
        
       

     

       32
       32
        
       buildPythonPackage rec {

     

       33
       33
        
         pname = "angr";

     

       34
       34
       -
         version = "9.2.35";

     

       34
       34
       +
         version = "9.2.36";

     

       35
       35
        
         format = "pyproject";

     

       36
       36
        
       

     

       37
       37
        
         disabled = pythonOlder "3.8";

     
···

       40
       40
        
           owner = pname;

     

       41
       41
        
           repo = pname;

     

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

     

       43
       43
       -
           hash = "sha256-zJ3dURT2T44Nl0KPSw8bTeJO33siBLAOu/lXGaQeEdQ=";

     

       43
       43
       +
           hash = "sha256-KVIrhzd3EoDIVImshfjZrBAiNkCtlFAd6Ox9ATsvPTY=";

     

       44
       44
        
         };

     

       45
       45
        
       

     

       46
       46
        
         propagatedBuildInputs = [

+2 -2

pkgs/development/python-modules/ansible/core.nix

···

       24
       24
        
       

     

       25
       25
        
       buildPythonPackage rec {

     

       26
       26
        
         pname = "ansible-core";

     

       27
       27
       -
         version = "2.14.0";

     

       27
       27
       +
         version = "2.14.2";

     

       28
       28
        
       

     

       29
       29
        
         src = fetchPypi {

     

       30
       30
        
           inherit pname version;

     

       31
       31
       -
           hash = "sha256-+ki0gctiO/ebuQPyIwl2gaDBPhtOx+eOfdfYWNNqNLI=";

     

       31
       31
       +
           hash = "sha256-R/DUtBJbWO26ZDWkfzfL5qGNpUWU0Y+BKVi7DLWNTmU=";

     

       32
       32
        
         };

     

       33
       33
        
       

     

       34
       34
        
         # ansible_connection is already wrapped, so don't pass it through

+2 -2

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

···

       12
       12
        
       

     

       13
       13
        
       buildPythonPackage rec {

     

       14
       14
        
         pname = "apycula";

     

       15
       15
       -
         version = "0.6.1";

     

       15
       15
       +
         version = "0.6.2";

     

       16
       16
        
         format = "setuptools";

     

       17
       17
        
       

     

       18
       18
        
         disabled = pythonOlder "3.8";

     
···

       20
       20
        
         src = fetchPypi {

     

       21
       21
        
           inherit version;

     

       22
       22
        
           pname = "Apycula";

     

       23
       23
       -
           hash = "sha256-/XQ/Q4/LzCBDaTindbBENOh5OSIH2JPLyiYFWT9DcP4=";

     

       23
       23
       +
           hash = "sha256-WnxH/AKi7j2u1SWVtyggUD09OqXfOST1Ayr9DrbYMcQ=";

     

       24
       24
        
         };

     

       25
       25
        
       

     

       26
       26
        
         nativeBuildInputs = [

+2 -2

pkgs/development/python-modules/arcam-fmj/default.nix

···

       12
       12
        
       

     

       13
       13
        
       buildPythonPackage rec {

     

       14
       14
        
         pname = "arcam-fmj";

     

       15
       15
       -
         version = "1.0.1";

     

       15
       15
       +
         version = "1.1.0";

     

       16
       16
        
         format = "setuptools";

     

       17
       17
        
       

     

       18
       18
        
         disabled = pythonOlder "3.8";

     
···

       21
       21
        
           owner = "elupus";

     

       22
       22
        
           repo = "arcam_fmj";

     

       23
       23
        
           rev = "refs/tags/${version}";

     

       24
       24
       -
           hash = "sha256-Lmz701qdqFlXro279AdNx+P1o3Q/Om63jKvy854ogto=";

     

       24
       24
       +
           hash = "sha256-oXMoDpb4tg4iYAanTfPzeFp/IQl4bIELCTdM24hM84A=";

     

       25
       25
        
         };

     

       26
       26
        
       

     

       27
       27
        
         propagatedBuildInputs = [

+2 -2

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

···

       8
       8
        
       

     

       9
       9
        
       buildPythonPackage rec {

     

       10
       10
        
         pname = "archinfo";

     

       11
       11
       -
         version = "9.2.35";

     

       11
       11
       +
         version = "9.2.36";

     

       12
       12
        
         format = "pyproject";

     

       13
       13
        
       

     

       14
       14
        
         disabled = pythonOlder "3.8";

     
···

       17
       17
        
           owner = "angr";

     

       18
       18
        
           repo = pname;

     

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

     

       20
       20
       -
           hash = "sha256-/GGchV+B/1gleZM0mW8vVk/9Uwf1zYH0B7HwziAla6w=";

     

       20
       20
       +
           hash = "sha256-anZsvDIH1AWaFUG5UTuyQiOKeoUB/+MSbu5pjPZJxag=";

     

       21
       21
        
         };

     

       22
       22
        
       

     

       23
       23
        
         nativeBuildInputs = [

+3 -3

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

···

       9
       9
        
       

     

       10
       10
        
       buildPythonPackage rec {

     

       11
       11
        
         pname = "asyncmy";

     

       12
       12
       -
         version = "0.2.5";

     

       12
       12
       +
         version = "0.2.6";

     

       13
       13
        
         format = "pyproject";

     

       14
       14
        
       

     

       15
       15
        
         disabled = pythonOlder "3.7";

     
···

       17
       17
        
         src = fetchFromGitHub {

     

       18
       18
        
           owner = "long2ice";

     

       19
       19
        
           repo = pname;

     

       20
       20
       -
           rev = "v${version}";

     

       21
       21
       -
           sha256 = "sha256-yLAse8p+2RYHJmDwD5vrHlf29URB+kdupjD1DwTcRAc=";

     

       20
       20
       +
           rev = "refs/tags/v${version}";

     

       21
       21
       +
           sha256 = "sha256-UWwqQ0ZYGoOsgRC7ROV9DDBQ/l/vXWB6uHpQ/WaFRAw=";

     

       22
       22
        
         };

     

       23
       23
        
       

     

       24
       24
        
         nativeBuildInputs = [

+2 -2

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

···

       13
       13
        
       

     

       14
       14
        
       buildPythonPackage rec {

     

       15
       15
        
         pname = "claripy";

     

       16
       16
       -
         version = "9.2.35";

     

       16
       16
       +
         version = "9.2.36";

     

       17
       17
        
         format = "pyproject";

     

       18
       18
        
       

     

       19
       19
        
         disabled = pythonOlder "3.8";

     
···

       22
       22
        
           owner = "angr";

     

       23
       23
        
           repo = pname;

     

       24
       24
        
           rev = "refs/tags/v${version}";

     

       25
       25
       -
           hash = "sha256-vfyrYcwQopwSxGAA+8JFCkog0Po/s9HkGI3PJzSALSI=";

     

       25
       25
       +
           hash = "sha256-gF8T1ZTvTjyt+kEOxI3ryDJOZv4go54VTxSGEdUyGt4=";

     

       26
       26
        
         };

     

       27
       27
        
       

     

       28
       28
        
         nativeBuildInputs = [

+2 -2

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

···

       16
       16
        
       

     

       17
       17
        
       let

     

       18
       18
        
         # The binaries are following the argr projects release cycle

     

       19
       19
       -
         version = "9.2.35";

     

       19
       19
       +
         version = "9.2.36";

     

       20
       20
        
       

     

       21
       21
        
         # Binary files from https://github.com/angr/binaries (only used for testing and only here)

     

       22
       22
        
         binaries = fetchFromGitHub {

     
···

       38
       38
        
           owner = "angr";

     

       39
       39
        
           repo = pname;

     

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

     

       41
       41
       -
           hash = "sha256-0qDSxB77kKwYCLPWt/Wb//LLTJC8WJIv0Cw+HwE21sQ=";

     

       41
       41
       +
           hash = "sha256-XqoBFV87m/uz0proGDtbaewsoY8vsA6ToGwdv7xvO9Y=";

     

       42
       42
        
         };

     

       43
       43
        
       

     

       44
       44
        
         nativeBuildInputs = [

+2 -2

pkgs/development/python-modules/clickhouse-driver/default.nix

···

       16
       16
        
       

     

       17
       17
        
       buildPythonPackage rec {

     

       18
       18
        
         pname = "clickhouse-driver";

     

       19
       19
       -
         version = "0.2.2";

     

       19
       19
       +
         version = "0.2.5";

     

       20
       20
        
       

     

       21
       21
        
         # pypi source doesn't contain tests

     

       22
       22
        
         src = fetchFromGitHub {

     

       23
       23
        
           owner = "mymarilyn";

     

       24
       24
        
           repo = "clickhouse-driver";

     

       25
       25
        
           rev = version;

     

       26
       26
       -
           sha256 = "0sx4jbadx9frzhqnj8b9w9l508x1r7j7b9883h7xq93lf00rxkfz";

     

       26
       26
       +
           hash = "sha256-o5v37jPKmvUW4GFVD742nHSdO0g0z2FA4FkacbaRfNA=";

     

       27
       27
        
         };

     

       28
       28
        
       

     

       29
       29
        
         propagatedBuildInputs = [

+2 -2

pkgs/development/python-modules/django/4.nix

···

       43
       43
        
       

     

       44
       44
        
       buildPythonPackage rec {

     

       45
       45
        
         pname = "Django";

     

       46
       46
       -
         version = "4.1.5";

     

       46
       46
       +
         version = "4.1.6";

     

       47
       47
        
         format = "pyproject";

     

       48
       48
        
       

     

       49
       49
        
         disabled = pythonOlder "3.8";

     

       50
       50
        
       

     

       51
       51
        
         src = fetchPypi {

     

       52
       52
        
           inherit pname version;

     

       53
       53
       -
           hash = "sha256-/1br1+rQ/V2+Bv4VewAkp6rqLgWTuzeF+1lM+U2tWO8=";

     

       53
       53
       +
           hash = "sha256-vOsP4aOGeBrweIyuQQhiJ1bNBed3VEje7ASnHd+HaF0=";

     

       54
       54
        
         };

     

       55
       55
        
       

     

       56
       56
        
         patches = [

+2 -2

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

···

       9
       9
        
       

     

       10
       10
        
       stdenv.mkDerivation rec {

     

       11
       11
        
         pname = "eigenpy";

     

       12
       12
       -
         version = "2.9.0";

     

       12
       12
       +
         version = "2.9.1";

     

       13
       13
        
       

     

       14
       14
        
         src = fetchFromGitHub {

     

       15
       15
        
           owner = "stack-of-tasks";

     

       16
       16
        
           repo = pname;

     

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

     

       18
       18
        
           fetchSubmodules = true;

     

       19
       19
       -
           hash = "sha256-gYGJutTnvq5ERv6tDff6b+t7Kitnx9QAD/6hauHxOt4=";

     

       19
       19
       +
           hash = "sha256-R+j68l2N+Qb2uqdl+Ng6nwj8O3YhqXgnYZBIzZ06aRA=";

     

       20
       20
        
         };

     

       21
       21
        
       

     

       22
       22
        
         strictDeps = true;

+3 -3

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

···

       13
       13
        
       

     

       14
       14
        
       buildPythonPackage rec {

     

       15
       15
        
         pname = "etebase";

     

       16
       16
       -
         version = "0.31.5";

     

       16
       16
       +
         version = "0.31.6";

     

       17
       17
        
       

     

       18
       18
        
         src = fetchFromGitHub {

     

       19
       19
        
           owner = "etesync";

     

       20
       20
        
           repo = "etebase-py";

     

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

     

       22
       22
       -
           hash = "sha256-87t3toMaApnOSPBKfTGGLo2VRLqU8irFac9lg3kA1eE=";

     

       22
       22
       +
           hash = "sha256-T61nPW3wjBRjmJ81w59T1b/Kxrwwqvyj3gILE9OF/5Q=";

     

       23
       23
        
         };

     

       24
       24
        
       

     

       25
       25
        
         cargoDeps = rustPlatform.fetchCargoTarball {

     

       26
       26
        
           inherit src;

     

       27
       27
        
           name = "${pname}-${version}";

     

       28
       28
       -
           hash = "sha256-Qg0aJ6CZaPxGneIs4o402A+fhI/nlJ9X/XdMFqkD/YY=";

     

       28
       28
       +
           hash = "sha256-wrMNtcaLAsWBVeJbYbYo+Xmobl01lnUbR9NUqqUzUgU=";

     

       29
       29
        
         };

     

       30
       30
        
       

     

       31
       31
        
         format = "pyproject";

+2 -2

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

···

       15
       15
        
       

     

       16
       16
        
       buildPythonPackage rec {

     

       17
       17
        
         pname = "fastavro";

     

       18
       18
       -
         version = "1.7.0";

     

       18
       18
       +
         version = "1.7.1";

     

       19
       19
        
       

     

       20
       20
        
         disabled = pythonOlder "3.6";

     

       21
       21
        
         src = fetchFromGitHub {

     

       22
       22
        
           owner = pname;

     

       23
       23
        
           repo = pname;

     

       24
       24
        
           rev = "refs/tags/${version}";

     

       25
       25
       -
           sha256 = "sha256-vzaaX3wj1UkFGCohxYlPw6NA0b+oV/2JtpYXC4zncjk=";

     

       25
       25
       +
           sha256 = "sha256-oFBOHcrtJe9u/hdW4p8GgIJ2g4oiSNa+qbDFBuMB/HQ=";

     

       26
       26
        
         };

     

       27
       27
        
       

     

       28
       28
        
         preBuild = ''

+6 -12

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

···

       1
       1
       -
       { stdenv, lib, buildPythonPackage, fetchPypi, isPy3k, pythonOlder

     

       1
       1
       +
       { stdenv, lib, buildPythonPackage, fetchPypi, isPy3k, pythonOlder, cython

     

       2
       2
        
       , attrs, click, cligj, click-plugins, six, munch, enum34

     

       3
       3
        
       , pytestCheckHook, boto3, mock, giflib, pytz

     

       4
       4
        
       , gdal, certifi

     

       5
       5
       -
       , fetchpatch

     

       6
       5
        
       }:

     

       7
       6
        
       

     

       8
       7
        
       buildPythonPackage rec {

     

       9
       8
        
         pname = "fiona";

     

       10
       10
       -
         version = "1.8.22";

     

       9
       9
       +
         version = "1.9.0";

     

       11
       10
        
       

     

       12
       11
        
         src = fetchPypi {

     

       13
       12
        
           pname = "Fiona";

     

       14
       13
        
           inherit version;

     

       15
       15
       -
           sha256 = "sha256-qCqZzps+eCV0AVfEXJ+yJZ1OkvCohqqsJfDbQP/h7qM=";

     

       14
       14
       +
           hash = "sha256-bkh8v7pahJ+98G5FFp/X4fFmL0Tz1xerS5RgRrJFfq4=";

     

       16
       15
        
         };

     

       17
       16
        
       

     

       18
       18
       -
         patches = [

     

       19
       19
       -
           # https://github.com/Toblerity/Fiona/pull/1122

     

       20
       20
       -
           (fetchpatch {

     

       21
       21
       -
             url = "https://github.com/Toblerity/Fiona/commit/fa632130dcd9dfbb982ecaa4911b3fab3459168f.patch";

     

       22
       22
       -
             hash = "sha256-IuNHr3yBqS1jY9Swvcq8XPv6BpVlInDx0FVuzEMaYTY=";

     

       23
       23
       -
           })

     

       24
       24
       -
         ];

     

       25
       25
       -
       

     

       26
       17
        
         CXXFLAGS = lib.optionalString stdenv.cc.isClang "-std=c++11";

     

       27
       18
        
       

     

       28
       19
        
         nativeBuildInputs = [

     

       20
       20
       +
           cython

     

       29
       21
        
           gdal # for gdal-config

     

       30
       22
        
         ];

     

       31
       23
        
       

     
···

       61
       53
        
           # https://github.com/Toblerity/Fiona/issues/1164

     

       62
       54
        
           "test_no_append_driver_cannot_append"

     

       63
       55
        
         ];

     

       56
       56
       +
       

     

       57
       57
       +
         pythonImportsCheck = [ "fiona" ];

     

       64
       58
        
       

     

       65
       59
        
         meta = with lib; {

     

       66
       60
        
           description = "OGR's neat, nimble, no-nonsense API for Python";

+3 -3

pkgs/development/python-modules/ghrepo-stats/default.nix

···

       9
       9
        
       

     

       10
       10
        
       buildPythonPackage rec {

     

       11
       11
        
         pname = "ghrepo-stats";

     

       12
       12
       -
         version = "0.5.0";

     

       12
       12
       +
         version = "0.5.1";

     

       13
       13
        
         format = "setuptools";

     

       14
       14
        
       

     

       15
       15
        
         disabled = pythonOlder "3.8";

     
···

       17
       17
        
         src = fetchFromGitHub {

     

       18
       18
        
           owner = "mrbean-bremen";

     

       19
       19
        
           repo = pname;

     

       20
       20
       -
           rev = "v${version}";

     

       21
       21
       -
           hash = "sha256-rTW6wADpkP9GglNmQNVecHfA2yJZuzYhJfsLfucbcgY=";

     

       20
       20
       +
           rev = "refs/tags/v${version}";

     

       21
       21
       +
           hash = "sha256-QHFwIfX0rSVnWgxe82zQXMwIS99CiPgprfoMbuXvXH0=";

     

       22
       22
        
         };

     

       23
       23
        
       

     

       24
       24
        
         postPatch = ''

+2 -2

pkgs/development/python-modules/glean-parser/default.nix

···

       15
       15
        
       

     

       16
       16
        
       buildPythonPackage rec {

     

       17
       17
        
         pname = "glean-parser";

     

       18
       18
       -
         version = "6.4.0";

     

       18
       18
       +
         version = "7.0.0";

     

       19
       19
        
         format = "setuptools";

     

       20
       20
        
       

     

       21
       21
        
         disabled = pythonOlder "3.6";

     
···

       23
       23
        
         src = fetchPypi {

     

       24
       24
        
           pname = "glean_parser";

     

       25
       25
        
           inherit version;

     

       26
       26
       -
           hash = "sha256-9+U9kRMkcQY0tjao6Pmi0STqh0xw0pFU0/xZXlawkKM=";

     

       26
       26
       +
           hash = "sha256-xIlg3W/A3FBvVOEin/ku0QdmzGXlmOm5yLeYvoGkzNU=";

     

       27
       27
        
         };

     

       28
       28
        
       

     

       29
       29
        
         postPatch = ''

+4 -9

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

···

       17
       17
        
       

     

       18
       18
        
       buildPythonPackage rec {

     

       19
       19
        
         pname = "glean-sdk";

     

       20
       20
       -
         version = "51.2.0";

     

       20
       20
       +
         version = "52.2.0";

     

       21
       21
        
       

     

       22
       22
        
         disabled = pythonOlder "3.6";

     

       23
       23
        
       

     

       24
       24
        
         src = fetchPypi {

     

       25
       25
        
           inherit pname version;

     

       26
       26
       -
           hash = "sha256-4EXCYthMabdmxWYltcnO0UTNeAYXwXQeRfwxt1WD3Ug=";

     

       26
       26
       +
           hash = "sha256-iW432YtZtRGUWia33Lsnu+aQuedhBJdh8dZ30FPg6Vk=";

     

       27
       27
        
         };

     

       28
       28
        
       

     

       29
       29
        
         cargoDeps = rustPlatform.fetchCargoTarball {

     

       30
       30
        
           inherit src;

     

       31
       31
        
           name = "${pname}-${version}";

     

       32
       32
       -
           hash = "sha256-qOGoonutuIY+0UVaVSVVt0NbqEICdNs3qHWG0Epmkl0=";

     

       32
       32
       +
           hash = "sha256-/7qKIQglNKGveKFtPeqd35Mq2hH/20BGTgDBgip4PnI=";

     

       33
       33
        
         };

     

       34
       34
        
       

     

       35
       35
        
         nativeBuildInputs = [

     
···

       56
       56
        
           "test_client_activity_api"

     

       57
       57
        
         ];

     

       58
       58
        
       

     

       59
       59
       -
         postPatch = ''

     

       60
       60
       -
           substituteInPlace glean-core/python/setup.py \

     

       61
       61
       -
             --replace "glean_parser==5.0.1" "glean_parser>=5.0.1"

     

       62
       62
       -
         '';

     

       63
       63
       -
       

     

       64
       59
        
         pythonImportsCheck = [

     

       65
       60
        
           "glean"

     

       66
       61
        
         ];

     
···

       70
       65
        
           description = "Telemetry client libraries and are a part of the Glean project";

     

       71
       66
        
           homepage = "https://mozilla.github.io/glean/book/index.html";

     

       72
       67
        
           license = licenses.mpl20;

     

       73
       73
       -
           maintainers = [];

     

       68
       68
       +
           maintainers = with maintainers; [ melling ];

     

       74
       69
        
         };

     

       75
       70
        
       }

+19 -18

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

···

       1
       1
        
       { lib

     

       2
       2
       -
       , fetchpatch

     

       3
       2
        
       , buildPythonPackage

     

       4
       3
        
       , fetchPypi

     

       5
       5
       -
       , pythonOlder

     

       4
       4
       +
       , fetchpatch

     

       6
       5
        
       , swig2

     

       7
       6
        
       , openssl

     

       8
       7
        
       , typing

     

       8
       8
       +
       , parameterized

     

       9
       9
        
       }:

     

       10
       10
        
       

     

       11
       11
        
       

     

       12
       12
        
       buildPythonPackage rec {

     

       13
       13
       -
         version = "0.36.0";

     

       13
       13
       +
         version = "0.38.0";

     

       14
       14
        
         pname = "M2Crypto";

     

       15
       15
        
       

     

       16
       16
        
         src = fetchPypi {

     

       17
       17
        
           inherit pname version;

     

       18
       18
       -
           sha256 = "1hadbdckmjzfb8qzbkafypin6sakfx35j2qx0fsivh757s7c2hhm";

     

       18
       18
       +
           sha256 = "sha256-mfImCjCQHJSajcbV+CzVMS/7iryS52YzuvIxu7yy3ss=";

     

       19
       19
        
         };

     

       20
       20
        
       

     

       21
       21
        
         patches = [

     

       22
       22
       +
           # Use OpenSSL_version_num() instead of unrealiable parsing of .h file.

     

       23
       23
       +
           (fetchpatch {

     

       24
       24
       +
             url = "https://src.fedoraproject.org/rpms/m2crypto/raw/42951285c800f72e0f0511cec39a7f49e970a05c/f/m2crypto-MR271-opensslversion.patch";

     

       25
       25
       +
             hash = "sha256-e1/NHgWza+kum76MUFSofq9Ko3pML67PUfqWjcwIl+A=";

     

       26
       26
       +
           })

     

       27
       27
       +
           # Changed required to pass tests on OpenSSL 3.0

     

       28
       28
       +
           (fetchpatch {

     

       29
       29
       +
             url = "https://src.fedoraproject.org/rpms/m2crypto/raw/42951285c800f72e0f0511cec39a7f49e970a05c/f/m2crypto-0.38-ossl3-tests.patch";

     

       30
       30
       +
             hash = "sha256-B6JKoPh76+CIna6zmrvFj50DIp3pzg8aKyzz+Q5hqQ0=";

     

       31
       31
       +
           })

     

       32
       32
       +
           # Allow EVP tests fail on non-FIPS algorithms

     

       22
       33
        
           (fetchpatch {

     

       23
       23
       -
             url = "https://github.com/void-linux/void-packages/raw/7946d12eb3d815e5ecd4578f1a6133d948694370/srcpkgs/python-M2Crypto/patches/libressl.patch";

     

       24
       24
       -
             sha256 = "0z5qnkndg6ma5f5qqrid5m95i9kybsr000v3fdy1ab562kf65a27";

     

       34
       34
       +
             url = "https://src.fedoraproject.org/rpms/m2crypto/raw/42951285c800f72e0f0511cec39a7f49e970a05c/f/m2crypto-0.38-ossl3-tests-evp.patch";

     

       35
       35
       +
             hash = "sha256-jMUAphVBQMFaOJSeYUCQMV3WSe9VDQqG6GY5fDQXZnA=";

     

       25
       36
        
           })

     

       26
       37
        
         ];

     

       27
       27
       -
         patchFlags = [ "-p0" ];

     

       28
       38
        
       

     

       29
       29
       -
         nativeBuildInputs = [ swig2 ];

     

       30
       30
       -
         buildInputs = [ swig2 openssl ];

     

       31
       31
       -
       

     

       32
       32
       -
         propagatedBuildInputs = lib.optional (pythonOlder "3.5") typing;

     

       33
       33
       -
       

     

       34
       34
       -
         preConfigure = ''

     

       35
       35
       -
           substituteInPlace setup.py --replace "self.openssl = '/usr'" "self.openssl = '${openssl.dev}'"

     

       36
       36
       -
         '';

     

       37
       37
       -
       

     

       38
       38
       -
         doCheck = false; # another test that depends on the network.

     

       39
       39
       +
         nativeBuildInputs = [ swig2 openssl ];

     

       40
       40
       +
         buildInputs = [ openssl parameterized ];

     

       39
       41
        
       

     

       40
       42
        
         meta = with lib; {

     

       41
       43
        
           description = "A Python crypto and SSL toolkit";

     
···

       43
       45
        
           license = licenses.mit;

     

       44
       46
        
           maintainers = with maintainers; [ andrew-d ];

     

       45
       47
        
         };

     

       46
       46
       -
       

     

       47
       48
        
       }

+3 -3

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

···

       7
       7
        
       

     

       8
       8
        
       buildPythonPackage rec {

     

       9
       9
        
         pname = "minidb";

     

       10
       10
       -
         version = "2.0.6";

     

       10
       10
       +
         version = "2.0.7";

     

       11
       11
        
         format = "setuptools";

     

       12
       12
        
       

     

       13
       13
        
         disabled = pythonOlder "3.7";

     
···

       15
       15
        
         src = fetchFromGitHub {

     

       16
       16
        
           owner = "thp";

     

       17
       17
        
           repo = "minidb";

     

       18
       18
       -
           rev = version;

     

       19
       19
       -
           hash = "sha256-H7W+GBapT9uJgbPlARp4ZLKTN7hZlF/FbNo7rObqDM4=";

     

       18
       18
       +
           rev = "refs/tags/${version}";

     

       19
       19
       +
           hash = "sha256-0f2usKoHs4NO/Ir8MhyiAVZFYnUkVH5avdh3QdHzY6s=";

     

       20
       20
        
         };

     

       21
       21
        
       

     

       22
       22
        
         nativeCheckInputs = [

+2 -2

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

···

       19
       19
        
       

     

       20
       20
        
       buildPythonPackage rec {

     

       21
       21
        
         pname = "openstacksdk";

     

       22
       22
       -
         version = "0.103.0";

     

       22
       22
       +
         version = "1.0.0";

     

       23
       23
        
         format = "setuptools";

     

       24
       24
        
       

     

       25
       25
        
         disabled = pythonOlder "3.6";

     

       26
       26
        
       

     

       27
       27
        
         src = fetchPypi {

     

       28
       28
        
           inherit pname version;

     

       29
       29
       -
           hash = "sha256-T58RiYZgOWdDXzl2s+BZlQpxvY5BqDFsyK+y2WaKB0E=";

     

       29
       29
       +
           hash = "sha256-z2vVGeMB94S/51bB+Tf47ByvP9BWQ1TzQHpFGS8FR8w=";

     

       30
       30
        
         };

     

       31
       31
        
       

     

       32
       32
        
         propagatedBuildInputs = [

+75

pkgs/development/python-modules/piano-transcription-inference/default.nix

···

       1
       1
       +
       { stdenv

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , buildPythonPackage

     

       4
       4
       +
       , fetchPypi

     

       5
       5
       +
       , fetchpatch

     

       6
       6
       +
       , fetchurl

     

       7
       7
       +
       , librosa

     

       8
       8
       +
       , matplotlib

     

       9
       9
       +
       , mido

     

       10
       10
       +
       , torch

     

       11
       11
       +
       , torchlibrosa

     

       12
       12
       +
       }:

     

       13
       13
       +
       

     

       14
       14
       +
       buildPythonPackage rec {

     

       15
       15
       +
         pname = "piano-transcription-inference";

     

       16
       16
       +
         version = "0.0.5";

     

       17
       17
       +
         format = "setuptools";

     

       18
       18
       +
       

     

       19
       19
       +
         src = fetchPypi {

     

       20
       20
       +
           inherit pname version;

     

       21
       21
       +
           hash = "sha256-nbhuSkXuWrekFxwdNHaspuag+3K1cKwq90IpATBpWPY=";

     

       22
       22
       +
         };

     

       23
       23
       +
       

     

       24
       24
       +
         checkpoint = fetchurl {

     

       25
       25
       +
           name = "piano-transcription-inference.pth";

     

       26
       26
       +
           # The download url can be found in

     

       27
       27
       +
           # https://github.com/qiuqiangkong/piano_transcription_inference/blob/master/piano_transcription_inference/inference.py

     

       28
       28
       +
           url = "https://zenodo.org/record/4034264/files/CRNN_note_F1%3D0.9677_pedal_F1%3D0.9186.pth?download=1";

     

       29
       29
       +
           hash = "sha256-w/qXMHJb9Kdi8cFLyAzVmG6s2gGwJvWkolJc1geHYUE=";

     

       30
       30
       +
         };

     

       31
       31
       +
       

     

       32
       32
       +
         propagatedBuildInputs = [

     

       33
       33
       +
           librosa

     

       34
       34
       +
           matplotlib

     

       35
       35
       +
           mido

     

       36
       36
       +
           torch

     

       37
       37
       +
           torchlibrosa

     

       38
       38
       +
         ];

     

       39
       39
       +
       

     

       40
       40
       +
         patches = [

     

       41
       41
       +
           # Fix run against librosa 0.9.0

     

       42
       42
       +
           # https://github.com/qiuqiangkong/piano_transcription_inference/pull/10

     

       43
       43
       +
           (fetchpatch {

     

       44
       44
       +
             url = "https://github.com/qiuqiangkong/piano_transcription_inference/commit/b2d448916be771cd228f709c23c474942008e3e8.patch";

     

       45
       45
       +
             hash = "sha256-8O4VtFij//k3fhcbMRz4J8Iz4AdOPLkuk3UTxuCSy8U=";

     

       46
       46
       +
           })

     

       47
       47
       +
         ];

     

       48
       48
       +
       

     

       49
       49
       +
         postPatch = ''

     

       50
       50
       +
           substituteInPlace piano_transcription_inference/inference.py --replace \

     

       51
       51
       +
             "checkpoint_path='{}/piano_transcription_inference_data/note_F1=0.9677_pedal_F1=0.9186.pth'.format(str(Path.home()))" \

     

       52
       52
       +
             "checkpoint_path='$out/share/checkpoint.pth'"

     

       53
       53
       +
         '';

     

       54
       54
       +
       

     

       55
       55
       +
         postInstall = ''

     

       56
       56
       +
           mkdir "$out/share"

     

       57
       57
       +
           ln -s "${checkpoint}" "$out/share/checkpoint.pth"

     

       58
       58
       +
         '';

     

       59
       59
       +
       

     

       60
       60
       +
         # Project has no tests.

     

       61
       61
       +
         # In order to make pythonImportsCheck work, NUMBA_CACHE_DIR env var need to

     

       62
       62
       +
         # be set to a writable dir (https://github.com/numba/numba/issues/4032#issuecomment-488102702).

     

       63
       63
       +
         # pythonImportsCheck has no pre* hook, use checkPhase to wordaround that.

     

       64
       64
       +
         checkPhase = ''

     

       65
       65
       +
           export NUMBA_CACHE_DIR="$(mktemp -d)"

     

       66
       66
       +
         '';

     

       67
       67
       +
         pythonImportsCheck = [ "piano_transcription_inference" ];

     

       68
       68
       +
       

     

       69
       69
       +
         meta = with lib; {

     

       70
       70
       +
           description = "A piano transcription inference package";

     

       71
       71
       +
           homepage = "https://github.com/qiuqiangkong/piano_transcription_inference";

     

       72
       72
       +
           license = licenses.mit;

     

       73
       73
       +
           maintainers = with maintainers; [ azuwis ];

     

       74
       74
       +
         };

     

       75
       75
       +
       }

+2 -2

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

···

       21
       21
        
       

     

       22
       22
        
       buildPythonPackage rec {

     

       23
       23
        
         pname = "plugwise";

     

       24
       24
       -
         version = "0.27.4";

     

       24
       24
       +
         version = "0.27.5";

     

       25
       25
        
         format = "setuptools";

     

       26
       26
        
       

     

       27
       27
        
         disabled = pythonOlder "3.7";

     
···

       30
       30
        
           owner = pname;

     

       31
       31
        
           repo = "python-plugwise";

     

       32
       32
        
           rev = "refs/tags/v${version}";

     

       33
       33
       -
           hash = "sha256-Ti0ZQlWsZaGvpfCTUnGNzdKcqKO84fAtlIUWC0wiyTI=";

     

       33
       33
       +
           hash = "sha256-qEAXyWa5OjTpF4foi0ljHKbemIEHORPGE6vIVL57BOU=";

     

       34
       34
        
         };

     

       35
       35
        
       

     

       36
       36
        
         propagatedBuildInputs = [

+2 -2

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

···

       24
       24
        
       

     

       25
       25
        
       buildPythonPackage rec {

     

       26
       26
        
         pname = "python-benedict";

     

       27
       27
       -
         version = "0.28.0";

     

       27
       27
       +
         version = "0.28.3";

     

       28
       28
        
         format = "setuptools";

     

       29
       29
        
       

     

       30
       30
        
         disabled = pythonOlder "3.7";

     
···

       33
       33
        
           owner = "fabiocaccamo";

     

       34
       34
        
           repo = pname;

     

       35
       35
        
           rev = "refs/tags/${version}";

     

       36
       36
       -
           hash = "sha256-o5WeqAVg1oGumkQbWeBNJgWgHxz5UOvYpnHt8NviTKA=";

     

       36
       36
       +
           hash = "sha256-6gzmVOuJfNpNJlea4Am20HI98mgcKkwtU/28l7qg20Y=";

     

       37
       37
        
         };

     

       38
       38
        
       

     

       39
       39
        
         nativeBuildInputs = [

+2 -2

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

···

       13
       13
        
       

     

       14
       14
        
       buildPythonPackage rec {

     

       15
       15
        
         pname = "pyvex";

     

       16
       16
       -
         version = "9.2.35";

     

       16
       16
       +
         version = "9.2.36";

     

       17
       17
        
         format = "pyproject";

     

       18
       18
        
       

     

       19
       19
        
         disabled = pythonOlder "3.8";

     

       20
       20
        
       

     

       21
       21
        
         src = fetchPypi {

     

       22
       22
        
           inherit pname version;

     

       23
       23
       -
           hash = "sha256-4qLfwzJhmcB1CwWTOvgX9qzYSfd2f3WOcXh+Aer1O3I=";

     

       23
       23
       +
           hash = "sha256-KV/fkgYUt8hfpGxDO3CNNrC91BaI9W8T2mr2H4eJdxo=";

     

       24
       24
        
         };

     

       25
       25
        
       

     

       26
       26
        
         nativeBuildInputs = [

+23 -8

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

···

       1
       1
        
       { lib

     

       2
       2
        
       , buildPythonPackage

     

       3
       3
       -
       , isPy27

     

       3
       3
       +
       , pythonOlder

     

       4
       4
        
       , fetchFromGitHub

     

       5
       5
        
       , pytestCheckHook

     

       6
       6
       +
       , pythonRelaxDepsHook

     

       6
       7
        
       , dill

     

       8
       8
       +
       , lightning-utilities

     

       7
       9
        
       , numpy

     

       8
       10
        
       , torch

     

       9
       11
        
       , threadpoolctl

     
···

       12
       14
        
       

     

       13
       15
        
       buildPythonPackage rec {

     

       14
       16
        
         pname = "rising";

     

       15
       15
       -
         version = "0.2.1";

     

       16
       16
       -
       

     

       17
       17
       -
         disabled = isPy27;

     

       17
       17
       +
         version = "0.3.0";

     

       18
       18
       +
         disabled = pythonOlder "TODO";

     

       18
       19
        
       

     

       19
       20
        
         src = fetchFromGitHub {

     

       20
       21
        
           owner = "PhoenixDL";

     

       21
       22
        
           repo = pname;

     

       22
       22
       -
           rev = "v${version}";

     

       23
       23
       -
           sha256 = "15wYWToXRae1cMpHWbJwzAp0THx6ED9ixQgL+n1v9PI=";

     

       23
       23
       +
           rev = "refs/tags/v${version}";

     

       24
       24
       +
           hash = "sha256-sBzVTst5Tp2oZZ+Xsg3M7uAMbucL6idlpYwHvib3EaY=";

     

       24
       25
        
         };

     

       25
       26
        
       

     

       26
       26
       -
         propagatedBuildInputs = [ numpy torch threadpoolctl tqdm ];

     

       27
       27
       +
         nativeBuildInputs = [ pythonRelaxDepsHook ];

     

       28
       28
       +
       

     

       29
       29
       +
         pythonRelaxDeps = [ "lightning-utilities" ];

     

       30
       30
       +
       

     

       31
       31
       +
         propagatedBuildInputs = [

     

       32
       32
       +
           lightning-utilities numpy torch threadpoolctl tqdm

     

       33
       33
       +
         ];

     

       27
       34
        
         nativeCheckInputs = [ dill pytestCheckHook ];

     

       28
       35
        
       

     

       29
       29
       -
         disabledTests = [ "test_affine" ];  # deprecated division operator '/'

     

       36
       36
       +
         pythonImportsCheck = [

     

       37
       37
       +
           "rising"

     

       38
       38
       +
           "rising.loading"

     

       39
       39
       +
           "rising.ops"

     

       40
       40
       +
           "rising.random"

     

       41
       41
       +
           "rising.transforms"

     

       42
       42
       +
           "rising.transforms.functional"

     

       43
       43
       +
           "rising.utils"

     

       44
       44
       +
         ];

     

       30
       45
        
       

     

       31
       46
        
         meta = {

     

       32
       47
        
           description = "High-performance data loading and augmentation library in PyTorch";

+8 -5

pkgs/development/python-modules/tensorflow-probability/default.nix

···

       1
       1
        
       { lib

     

       2
       2
       +
       , stdenv

     

       2
       3
        
       , fetchFromGitHub

     

       3
       3
       -
       , bazel_3

     

       4
       4
       +
       , bazel_6

     

       4
       5
        
       , buildBazelPackage

     

       5
       6
        
       , buildPythonPackage

     

       7
       7
       +
       , cctools

     

       6
       8
        
       , python

     

       7
       9
        
       , setuptools

     

       8
       10
        
       , wheel

     
···

       25
       27
        
       }:

     

       26
       28
        
       

     

       27
       29
        
       let

     

       28
       28
       -
         version = "0.15.0";

     

       30
       30
       +
         version = "0.19.0";

     

       29
       31
        
         pname = "tensorflow_probability";

     

       30
       32
        
       

     

       31
       33
        
         # first build all binaries and generate setup.py using bazel

     
···

       35
       37
        
             owner = "tensorflow";

     

       36
       38
        
             repo = "probability";

     

       37
       39
        
             rev = "v" + version;

     

       38
       38
       -
             sha256 = "155fgmra90s08vjnp61qxdrpzq74xa3kdzhgdkavwgc25pvxn3mi";

     

       40
       40
       +
             hash = "sha256-ZkQ20Qt/RF/leVP6Kc38tGgPz+C6lEuHvoL+s97oksE=";

     

       39
       41
        
           };

     

       40
       42
        
           nativeBuildInputs = [

     

       41
       43
        
             # needed to create the output wheel in installPhase

     
···

       46
       48
        
             tensorflow

     

       47
       49
        
           ];

     

       48
       50
        
       

     

       49
       49
       -
           bazel = bazel_3;

     

       51
       51
       +
           bazel = bazel_6;

     

       50
       52
        
       

     

       51
       53
        
           bazelTarget = ":pip_pkg";

     

       54
       54
       +
           LIBTOOL = lib.optionalString stdenv.isDarwin "${cctools}/bin/libtool";

     

       52
       55
        
       

     

       53
       56
        
           fetchAttrs = {

     

       54
       54
       -
             sha256 = "0sgxdlw5x3dydy53l10vbrj8smh78b7r1wff8jxcgp4w69mk8zfm";

     

       57
       57
       +
             sha256 = "sha256-pST4R45mWC5j0ngkkRe+hmostaMploW0+BN3WKPt0t0=";

     

       55
       58
        
           };

     

       56
       59
        
       

     

       57
       60
        
           buildAttrs = {

+50

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

···

       1
       1
       +
       { stdenv

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , buildPythonPackage

     

       4
       4
       +
       , fetchPypi

     

       5
       5
       +
       , fetchpatch

     

       6
       6
       +
       , librosa

     

       7
       7
       +
       , numpy

     

       8
       8
       +
       , torch

     

       9
       9
       +
       }:

     

       10
       10
       +
       

     

       11
       11
       +
       buildPythonPackage rec {

     

       12
       12
       +
         pname = "torchlibrosa";

     

       13
       13
       +
         version = "0.0.9";

     

       14
       14
       +
         format = "setuptools";

     

       15
       15
       +
       

     

       16
       16
       +
         src = fetchPypi {

     

       17
       17
       +
           inherit pname version;

     

       18
       18
       +
           hash = "sha256-+LzejKvLlJIIwWm9rYPCWQDSueIwnG5gbkwNE+wbv0A=";

     

       19
       19
       +
         };

     

       20
       20
       +
       

     

       21
       21
       +
         propagatedBuildInputs = [

     

       22
       22
       +
           librosa

     

       23
       23
       +
           numpy

     

       24
       24
       +
           torch

     

       25
       25
       +
         ];

     

       26
       26
       +
       

     

       27
       27
       +
         patches = [

     

       28
       28
       +
           # Fix run against librosa 0.9.0, https://github.com/qiuqiangkong/torchlibrosa/pull/8

     

       29
       29
       +
           (fetchpatch {

     

       30
       30
       +
             url = "https://github.com/qiuqiangkong/torchlibrosa/commit/eec7e7559a47d0ef0017322aee29a31dad0572d5.patch";

     

       31
       31
       +
             hash = "sha256-c1x3MA14Plm7+lVuqiuLWgSY6FW615qnKbcWAfbrcas=";

     

       32
       32
       +
           })

     

       33
       33
       +
         ];

     

       34
       34
       +
       

     

       35
       35
       +
         # Project has no tests.

     

       36
       36
       +
         # In order to make pythonImportsCheck work, NUMBA_CACHE_DIR env var need to

     

       37
       37
       +
         # be set to a writable dir (https://github.com/numba/numba/issues/4032#issuecomment-488102702).

     

       38
       38
       +
         # pythonImportsCheck has no pre* hook, use checkPhase to workaround that.

     

       39
       39
       +
         checkPhase = ''

     

       40
       40
       +
           export NUMBA_CACHE_DIR="$(mktemp -d)"

     

       41
       41
       +
         '';

     

       42
       42
       +
         pythonImportsCheck = [ "torchlibrosa" ];

     

       43
       43
       +
       

     

       44
       44
       +
         meta = with lib; {

     

       45
       45
       +
           description = "PyTorch implemention of part of librosa functions";

     

       46
       46
       +
           homepage = "https://github.com/qiuqiangkong/torchlibrosa";

     

       47
       47
       +
           license = licenses.mit;

     

       48
       48
       +
           maintainers = with maintainers; [ azuwis ];

     

       49
       49
       +
         };

     

       50
       50
       +
       }

+2 -2

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

···

       13
       13
        
       

     

       14
       14
        
       stdenv.mkDerivation rec {

     

       15
       15
        
         pname = "cppcheck";

     

       16
       16
       -
         version = "2.9.3";

     

       16
       16
       +
         version = "2.10";

     

       17
       17
        
       

     

       18
       18
        
         src = fetchFromGitHub {

     

       19
       19
        
           owner = "danmar";

     

       20
       20
        
           repo = "cppcheck";

     

       21
       21
        
           rev = version;

     

       22
       22
       -
           hash = "sha256-AaZzr5r+tpG5M40HSx45KCUBPhN/nSpXxS5H3FuSx2c=";

     

       22
       22
       +
           hash = "sha256-Ss35foFlh4sw6TxMp++0b9E5KDUjBpDPuWIHsak8OGY=";

     

       23
       23
        
         };

     

       24
       24
        
       

     

       25
       25
        
         buildInputs = [ pcre

+3 -3

pkgs/development/tools/biodiff/default.nix

···

       2
       2
        
       

     

       3
       3
        
       rustPlatform.buildRustPackage rec {

     

       4
       4
        
         pname = "biodiff";

     

       5
       5
       -
         version = "1.0.3";

     

       5
       5
       +
         version = "1.0.4";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "8051Enthusiast";

     

       9
       9
        
           repo = "biodiff";

     

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

     

       11
       11
       -
           sha256 = "sha256-ZIZ6XpRuqhacpvi1kf7zvMszzbF8IvWrMlxAZnJJSxE=";

     

       11
       11
       +
           sha256 = "sha256-anGiqTiZVm6q8BII1Ahg2ph7OwX5isCa16orEcf4aFE=";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
       -
         cargoSha256 = "sha256-/LrrHK9j6xg3J56ubM9RdkJeMn4nvpddUGMtHu2s6OE=";

     

       14
       14
       +
         cargoSha256 = "sha256-uyATu6M04IRFtzFb2ox0xUYFXjkW+t+71Iy58TuqCko=";

     

       15
       15
        
       

     

       16
       16
        
         meta = with lib; {

     

       17
       17
        
           description = "Hex diff viewer using alignment algorithms from biology";

+2 -2

pkgs/development/tools/ddosify/default.nix

···

       2
       2
        
       

     

       3
       3
        
       buildGoModule rec {

     

       4
       4
        
         pname = "ddosify";

     

       5
       5
       -
         version = "0.13.0";

     

       5
       5
       +
         version = "0.13.1";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = pname;

     

       9
       9
        
           repo = pname;

     

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

     

       11
       11
       -
           sha256 = "sha256-tw6rrhFhuIsVAj5IqSHGHSYheDqGENLDxiJr+PQno1U=";

     

       11
       11
       +
           sha256 = "sha256-bS/7S4PxZSTYvxLFmC486PBHNhkGUIPAnUJQztp3ouw=";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         vendorHash = "sha256-3y5ppTtvGqwWhgnVBpP4gf26DHKPnSNYK4jfhBiYDwY=";

+3 -3

pkgs/development/tools/goa/default.nix

···

       5
       5
        
       

     

       6
       6
        
       buildGoModule rec {

     

       7
       7
        
         pname = "goa";

     

       8
       8
       -
         version = "3.10.2";

     

       8
       8
       +
         version = "3.11.0";

     

       9
       9
        
       

     

       10
       10
        
         src = fetchFromGitHub {

     

       11
       11
        
           owner = "goadesign";

     

       12
       12
        
           repo = "goa";

     

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

     

       14
       14
       -
           sha256 = "sha256-cVCzuOZf2zFY01+t20sRArEFinWqvZ461jJIQIyf0yI=";

     

       14
       14
       +
           sha256 = "sha256-KgCF44kpr8dAHzLgoRKXfd9warQUiFggGZ/Dy/49j1Q=";

     

       15
       15
        
         };

     

       16
       16
       -
         vendorSha256 = "sha256-xLn7qGmBtNSnIZ7Gn4h/Aa037V0lO1jT/8P9PB7bH5o=";

     

       16
       16
       +
         vendorHash = "sha256-d76aeiSkW0sZeFylWIkCoquWzX78s2iaDeX3VE8cYfI=";

     

       17
       17
        
       

     

       18
       18
        
         subPackages = [ "cmd/goa" ];

     

       19
       19

+2 -2

pkgs/development/tools/jet/default.nix

···

       2
       2
        
       

     

       3
       3
        
       buildGraalvmNativeImage rec {

     

       4
       4
        
         pname = "jet";

     

       5
       5
       -
         version = "0.3.21";

     

       5
       5
       +
         version = "0.4.23";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchurl {

     

       8
       8
        
           url = "https://github.com/borkdude/${pname}/releases/download/v${version}/${pname}-${version}-standalone.jar";

     

       9
       9
       -
           sha256 = "sha256-p7jTPnXpDg1bbPMEmznFWNZ4lq/zt2fZUOE6IOc9akY=";

     

       9
       9
       +
           sha256 = "sha256-ijqMyzmF1C3+5oT3ho1MSkoGuFJGvjhh7WWF/JDV/j8=";

     

       10
       10
        
         };

     

       11
       11
        
       

     

       12
       12
        
         extraNativeImageBuildArgs = [

+3 -3

pkgs/development/tools/kubie/default.nix

···

       2
       2
        
       

     

       3
       3
        
       rustPlatform.buildRustPackage rec {

     

       4
       4
        
         pname = "kubie";

     

       5
       5
       -
         version = "0.19.1";

     

       5
       5
       +
         version = "0.19.2";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

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

     

       9
       9
        
           owner = "sbstp";

     

       10
       10
        
           repo = "kubie";

     

       11
       11
       -
           sha256 = "sha256-tZ4qa48I/J62bqc9eoSSpTrJjU+LpweF/kI1TMiFrEY=";

     

       11
       11
       +
           sha256 = "sha256-foY1fcIn+jywABwEVBWctx4zwLg7k2zxkpL8UAhx6kA=";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
       -
         cargoSha256 = "sha256-WpX1wkMPtUwT6KOi0Bij1tzGlDhti828wBSfzpXuZaY=";

     

       14
       14
       +
         cargoHash = "sha256-WHaORWwR7PeKacaCtXjTYMTCyZ4ZFWo1smVx5ig+Z9U=";

     

       15
       15
        
       

     

       16
       16
        
         nativeBuildInputs = [ installShellFiles ];

     

       17
       17

+3 -3

pkgs/development/tools/language-servers/jdt-language-server/default.nix

···

       7
       7
        
       

     

       8
       8
        
       stdenv.mkDerivation rec {

     

       9
       9
        
         pname = "jdt-language-server";

     

       10
       10
       -
         version = "1.17.0";

     

       11
       11
       -
         timestamp = "202210271413";

     

       10
       10
       +
         version = "1.19.0";

     

       11
       11
       +
         timestamp = "202301171536";

     

       12
       12
        
       

     

       13
       13
        
         src = fetchurl {

     

       14
       14
        
           url = "https://download.eclipse.org/jdtls/milestones/${version}/jdt-language-server-${version}-${timestamp}.tar.gz";

     

       15
       15
       -
           sha256 = "sha256-3NVzL3o/8LXR94/3Yma42XHfwNEFEVrmUijkeMs/vL0=";

     

       15
       15
       +
           sha256 = "sha256-9rreuMw2pODzOVX5PBmUZoV5ixUDilQyTsrnyCQ+IHs=";

     

       16
       16
        
         };

     

       17
       17
        
       

     

       18
       18
        
         sourceRoot = ".";

+3 -3

pkgs/development/tools/protoc-gen-go-vtproto/default.nix

···

       4
       4
        
       }:

     

       5
       5
        
       buildGoModule rec {

     

       6
       6
        
         pname = "protoc-gen-go-vtproto";

     

       7
       7
       -
         version = "0.3.0";

     

       7
       7
       +
         version = "0.4.0";

     

       8
       8
        
       

     

       9
       9
        
         src = fetchFromGitHub {

     

       10
       10
        
           owner = "planetscale";

     

       11
       11
        
           repo = "vtprotobuf";

     

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

     

       13
       13
       -
           sha256 = "sha256-fOF7n1WeQ3s1S+o5NbAoTUnqqk5IHtKvXCb2o8LmI5U=";

     

       13
       13
       +
           sha256 = "sha256-WtiXoQWjjFf+TP2zpAXNH05XdcrLSpw3S0TG4lkzp2E=";

     

       14
       14
        
         };

     

       15
       15
        
       

     

       16
       16
       -
         vendorSha256 = "sha256-JpSVO8h7+StLG9/dJQkmrIlh9zIHABoqP1hq+X5ajVs=";

     

       16
       16
       +
         vendorHash = "sha256-JpSVO8h7+StLG9/dJQkmrIlh9zIHABoqP1hq+X5ajVs=";

     

       17
       17
        
       

     

       18
       18
        
         excludedPackages = [ "conformance" ];

     

       19
       19

+2 -2

pkgs/development/tools/quick-lint-js/default.nix

···

       3
       3
        
       

     

       4
       4
        
       stdenv.mkDerivation rec {

     

       5
       5
        
         pname = "quick-lint-js";

     

       6
       6
       -
         version = "2.9.0";

     

       6
       6
       +
         version = "2.11.0";

     

       7
       7
        
       

     

       8
       8
        
         src = fetchFromGitHub {

     

       9
       9
        
           owner = "quick-lint";

     

       10
       10
        
           repo = "quick-lint-js";

     

       11
       11
        
           rev = version;

     

       12
       12
       -
           sha256 = "sha256-hWwEaUf+TntRfxI3HjJV+hJ+dV6TRncxSCbaxE1sIjs=";

     

       12
       12
       +
           sha256 = "sha256-hpDVR58Qez+TcAO77GXvjuH7NfBxdRvIi8WsBIuz3nI=";

     

       13
       13
        
         };

     

       14
       14
        
       

     

       15
       15
        
         nativeBuildInputs = [ cmake ninja ];

+3 -3

pkgs/development/tools/ruff/default.nix

···

       8
       8
        
       

     

       9
       9
        
       rustPlatform.buildRustPackage rec {

     

       10
       10
        
         pname = "ruff";

     

       11
       11
       -
         version = "0.0.238";

     

       11
       11
       +
         version = "0.0.239";

     

       12
       12
        
       

     

       13
       13
        
         src = fetchFromGitHub {

     

       14
       14
        
           owner = "charliermarsh";

     

       15
       15
        
           repo = pname;

     

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

     

       17
       17
       -
           sha256 = "sha256-hsJJsPJQrkzn+otpFhsESLRhfYEcUSXJULkScWPyQNk=";

     

       17
       17
       +
           sha256 = "sha256-ogAy1HrkoG7PWvDd4HlqTVNjrWpyWw2B+E9DANCoJNo=";

     

       18
       18
        
         };

     

       19
       19
        
       

     

       20
       20
       -
         cargoSha256 = "sha256-stEPoiXKXnjYcKqlJPwcjWAV4W2GLIp2lQ0ejVd/EF8=";

     

       20
       20
       +
         cargoSha256 = "sha256-C5ZOV2EUiV4W3J3jXS+aDyL3w+Rjx1YGTaE8ikqB2VQ=";

     

       21
       21
        
       

     

       22
       22
        
         nativeBuildInputs = [

     

       23
       23
        
           installShellFiles

+3 -3

pkgs/development/tools/rust/cargo-tally/default.nix

···

       2
       2
        
       

     

       3
       3
        
       rustPlatform.buildRustPackage rec {

     

       4
       4
        
         pname = "cargo-tally";

     

       5
       5
       -
         version = "1.0.21";

     

       5
       5
       +
         version = "1.0.22";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchCrate {

     

       8
       8
        
           inherit pname version;

     

       9
       9
       -
           sha256 = "sha256-YEsgXIZ4R2w0HOkTV8LOGi2g32nHRs63nhk9yVR4vak=";

     

       9
       9
       +
           sha256 = "sha256-h3w9xxzExDojJw2OIPMT9lQ/lzYQNf9WJVHBP+tOnPw=";

     

       10
       10
        
         };

     

       11
       11
        
       

     

       12
       12
       -
         cargoSha256 = "sha256-jLbYC862fZONvMHh0CLsiuUmn/hmAF6sRLuav3P+bck=";

     

       12
       12
       +
         cargoSha256 = "sha256-EPYfmRms00AE4NkmOJBnIKYOCFbjd2qwRi6/i09hQ6U=";

     

       13
       13
        
       

     

       14
       14
        
         buildInputs = lib.optionals stdenv.isDarwin (with darwin.apple_sdk_11_0.frameworks; [

     

       15
       15
        
           DiskArbitration

+3 -3

pkgs/development/tools/rust/cargo-zigbuild/default.nix

···

       2
       2
        
       

     

       3
       3
        
       rustPlatform.buildRustPackage rec {

     

       4
       4
        
         pname = "cargo-zigbuild";

     

       5
       5
       -
         version = "0.14.5";

     

       5
       5
       +
         version = "0.15.0";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "messense";

     

       9
       9
        
           repo = pname;

     

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

     

       11
       11
       -
           sha256 = "sha256-+H+T/PEpJyRySTJlVGbAevLzAEZs5J8BNqwZjiXhuuU=";

     

       11
       11
       +
           sha256 = "sha256-4Sp3PVhUvXn7FzPHHyyRBUHY5TQYEPLFdoI4ARQ4V0k=";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
       -
         cargoSha256 = "sha256-IOR/G+SPGl3MgOMjmsVPpvoode8U7K52vqs7yu0BdQk=";

     

       14
       14
       +
         cargoSha256 = "sha256-QplcedhsqFiAwcqBrEe2ns4DdZ+R/IuoKtkx8eGk19g=";

     

       15
       15
        
       

     

       16
       16
        
         nativeBuildInputs = [ makeWrapper ];

     

       17
       17

+45

pkgs/development/tools/ttfb/default.nix

···

       1
       1
       +
       { darwin

     

       2
       2
       +
       , fetchCrate

     

       3
       3
       +
       , lib

     

       4
       4
       +
       , openssl

     

       5
       5
       +
       , pkg-config

     

       6
       6
       +
       , rustPlatform

     

       7
       7
       +
       , stdenv

     

       8
       8
       +
       }:

     

       9
       9
       +
       

     

       10
       10
       +
       rustPlatform.buildRustPackage rec {

     

       11
       11
       +
         pname = "ttfb";

     

       12
       12
       +
         version = "1.6.0";

     

       13
       13
       +
       

     

       14
       14
       +
         src = fetchCrate {

     

       15
       15
       +
           inherit pname version;

     

       16
       16
       +
           sha256 = "sha256-o7kzQ8jtAqDwTUPtjeNqgotxREeWl7jQG+EDrYWJL/Q=";

     

       17
       17
       +
         };

     

       18
       18
       +
       

     

       19
       19
       +
         cargoSha256 = "sha256-ayyYrrFDVOYVjVo5TLaRn2mvmywe5BjQ7kRVV2r0iK8=";

     

       20
       20
       +
       

     

       21
       21
       +
         # The bin feature activates all dependencies of the binary. Otherwise,

     

       22
       22
       +
         # only the library is build.

     

       23
       23
       +
         buildFeatures = [ "bin" ];

     

       24
       24
       +
       

     

       25
       25
       +
         nativeBuildInputs = [ pkg-config ];

     

       26
       26
       +
       

     

       27
       27
       +
         buildInputs = [

     

       28
       28
       +
           openssl

     

       29
       29
       +
         ] ++ lib.optionals stdenv.isDarwin [

     

       30
       30
       +
           darwin.apple_sdk.frameworks.Security

     

       31
       31
       +
         ];

     

       32
       32
       +
       

     

       33
       33
       +
         meta = with lib; {

     

       34
       34
       +
           description = "CLI-Tool to measure the TTFB (time to first byte) of HTTP(S) requests";

     

       35
       35
       +
           longDescription = ''

     

       36
       36
       +
             This crate measures the times of DNS lookup, TCP connect, TLS handshake, and HTTP's TTFB

     

       37
       37
       +
             for a given IP or domain.

     

       38
       38
       +
           '';

     

       39
       39
       +
           homepage = "https://github.com/phip1611/ttfb";

     

       40
       40
       +
           changelog = "https://github.com/phip1611/ttfb/blob/v${version}/CHANGELOG.md";

     

       41
       41
       +
           license = with licenses; [ mit ];

     

       42
       42
       +
           maintainers = with maintainers; [ phip1611 ];

     

       43
       43
       +
         };

     

       44
       44
       +
       }

     

       45
       45
       +

+3 -3

pkgs/development/tools/typos/default.nix

···

       2
       2
        
       

     

       3
       3
        
       rustPlatform.buildRustPackage rec {

     

       4
       4
        
         pname = "typos";

     

       5
       5
       -
         version = "1.13.8";

     

       5
       5
       +
         version = "1.13.9";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "crate-ci";

     

       9
       9
        
           repo = pname;

     

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

     

       11
       11
       -
           hash = "sha256-ROMO6IkfpzFvB5Y4RRqrX5NnYzdHT1tsJBdCc1lDu7k=";

     

       11
       11
       +
           hash = "sha256-dAe19D9q5JXeWCnsfbz0NnAtnAQj0dyIy6cdyjqVxEg=";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
       -
         cargoHash = "sha256-VAVlzciWVKcgl/QKiF3Hfzx11jUi/0J9b6EmaZzG9qE=";

     

       14
       14
       +
         cargoHash = "sha256-gc3tDTsmgvMfLbWh5XALEpZuK6e8FXsomfq4U/xTPXM=";

     

       15
       15
        
       

     

       16
       16
        
         meta = with lib; {

     

       17
       17
        
           description = "Source code spell checker";

+3 -3

pkgs/development/tools/wasm-bindgen-cli/default.nix

···

       12
       12
        
       

     

       13
       13
        
       rustPlatform.buildRustPackage rec {

     

       14
       14
        
         pname = "wasm-bindgen-cli";

     

       15
       15
       -
         version = "0.2.83";

     

       15
       15
       +
         version = "0.2.84";

     

       16
       16
        
       

     

       17
       17
        
         src = fetchCrate {

     

       18
       18
        
           inherit pname version;

     

       19
       19
       -
           sha256 = "sha256-+PWxeRL5MkIfJtfN3/DjaDlqRgBgWZMa6dBt1Q+lpd0=";

     

       19
       19
       +
           sha256 = "sha256-0rK+Yx4/Jy44Fw5VwJ3tG243ZsyOIBBehYU54XP/JGk=";

     

       20
       20
        
         };

     

       21
       21
        
       

     

       22
       22
       -
         cargoSha256 = "sha256-GwLeA6xLt7I+NzRaqjwVpt1pzRex1/snq30DPv4FR+g=";

     

       22
       22
       +
         cargoSha256 = "sha256-vcpxcRlW1OKoD64owFF6mkxSqmNrvY+y3Ckn5UwEQ50=";

     

       23
       23
        
       

     

       24
       24
        
         nativeBuildInputs = [ pkg-config ];

     

       25
       25

+2 -2

pkgs/development/tools/zprint/default.nix

···

       2
       2
        
       

     

       3
       3
        
       buildGraalvmNativeImage rec {

     

       4
       4
        
         pname = "zprint";

     

       5
       5
       -
         version = "1.2.4";

     

       5
       5
       +
         version = "1.2.5";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchurl {

     

       8
       8
        
           url = "https://github.com/kkinnear/${pname}/releases/download/${version}/${pname}-filter-${version}";

     

       9
       9
       -
           sha256 = "sha256-PgmaKxTOZPgHhEfFA5FdHrKHHpfieoK2QZBYR3f0J8s=";

     

       9
       9
       +
           sha256 = "sha256-PWdR5jqyzvTk9HoxqDldwtZNik34dmebBtZZ5vtva4A=";

     

       10
       10
        
         };

     

       11
       11
        
       

     

       12
       12
        
         extraNativeImageBuildArgs = [

+2 -2

pkgs/games/crispy-doom/default.nix

···

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation rec {

     

       4
       4
        
         pname = "crispy-doom";

     

       5
       5
       -
         version = "5.11.1";

     

       5
       5
       +
         version = "5.12.0";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "fabiangreffrath";

     

       9
       9
        
           repo = pname;

     

       10
       10
        
           rev = "${pname}-${version}";

     

       11
       11
       -
           sha256 = "sha256-2Sjl9XO01ko0BwbFQSFv9mNoetyMa8Dxx17y0JmlLS0=";

     

       11
       11
       +
           sha256 = "sha256-ep48Lgxw0yKd7+Cx6wMEnOqu/1vjdCM36+TKv1sb1Tk=";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         postPatch = ''

+2 -2

pkgs/games/unciv/default.nix

···

       25
       25
        
       in

     

       26
       26
        
       stdenv.mkDerivation rec {

     

       27
       27
        
         pname = "unciv";

     

       28
       28
       -
         version = "4.4.3";

     

       28
       28
       +
         version = "4.4.6";

     

       29
       29
        
       

     

       30
       30
        
         src = fetchurl {

     

       31
       31
        
           url = "https://github.com/yairm210/Unciv/releases/download/${version}/Unciv.jar";

     

       32
       32
       -
           sha256 = "sha256-oPZdQEfWgVo4M0WDhKfDDB4GqnzQEM8x79FSa3jC+U0=";

     

       32
       32
       +
           sha256 = "sha256-I4EKYoN+36a65mcZ2UWH3Ws75Ojdmpw/6flKFmEuIk8=";

     

       33
       33
        
         };

     

       34
       34
        
       

     

       35
       35
        
         dontUnpack = true;

+15 -3

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

···

       5
       5
        
       , nixosTests

     

       6
       6
        
       }:

     

       7
       7
        
       

     

       8
       8
       +
       let

     

       9
       9
       +
         tag = "0.3.0";

     

       10
       10
       +
       in

     

       8
       11
        
       stdenv.mkDerivation {

     

       9
       12
        
         pname = "apfs";

     

       10
       10
       -
         version = "unstable-2022-10-20-${kernel.version}";

     

       13
       13
       +
         version = "${tag}-${kernel.version}";

     

       11
       14
        
       

     

       12
       15
        
         src = fetchFromGitHub {

     

       13
       16
        
           owner = "linux-apfs";

     

       14
       17
        
           repo = "linux-apfs-rw";

     

       15
       15
       -
           rev = "e6eb67c92d425d395eac1c4403629391bdd5064d";

     

       16
       16
       -
           sha256 = "sha256-6rv5qZCjOqt0FaNFhA3tYg6/SdssvoT8kPVhalajgOo=";

     

       18
       18
       +
           rev = "v${tag}";

     

       19
       19
       +
           sha256 = "sha256-ABFqkiIJuFapFsUIFHfw8+TujePZm7ZX/qHuFO2KdnQ=";

     

       17
       20
        
         };

     

       18
       21
        
       

     

       19
       22
        
         hardeningDisable = [ "pic" ];

     
···

       29
       32
        
       

     

       30
       33
        
         meta = with lib; {

     

       31
       34
        
           description = "APFS module for linux";

     

       35
       35
       +
           longDescription = ''

     

       36
       36
       +
             The Apple File System (APFS) is the copy-on-write filesystem currently

     

       37
       37
       +
             used on all Apple devices. This module provides a degree of experimental

     

       38
       38
       +
             support on Linux.

     

       39
       39
       +
             If you make use of the write support, expect data corruption.

     

       40
       40
       +
             Read-only support is somewhat more complete, with sealed volumes,

     

       41
       41
       +
             snapshots, and all the missing compression algorithms recently added.

     

       42
       42
       +
             Encryption is still not in the works though.

     

       43
       43
       +
           '';

     

       32
       44
        
           homepage = "https://github.com/linux-apfs/linux-apfs-rw";

     

       33
       45
        
           license = licenses.gpl2Only;

     

       34
       46
        
           platforms = platforms.linux;

+2 -7

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

···

       50
       50
        
       

     

       51
       51
        
       stdenv.mkDerivation rec {

     

       52
       52
        
         pname = "busybox";

     

       53
       53
       -
         version = "1.35.0";

     

       53
       53
       +
         version = "1.36.0";

     

       54
       54
        
       

     

       55
       55
        
         # Note to whoever is updating busybox: please verify that:

     

       56
       56
        
         # nix-build pkgs/stdenv/linux/make-bootstrap-tools.nix -A test

     

       57
       57
        
         # still builds after the update.

     

       58
       58
        
         src = fetchurl {

     

       59
       59
        
           url = "https://busybox.net/downloads/${pname}-${version}.tar.bz2";

     

       60
       60
       -
           sha256 = "sha256-+u6yRMNaNIozT0pZ5EYm7ocPsHtohNaMEK6LwZ+DppQ=";

     

       60
       60
       +
           sha256 = "sha256-VCdQyK98smMOIBeAtPmfPczusG9QW0eexoJBweavYaU=";

     

       61
       61
        
         };

     

       62
       62
        
       

     

       63
       63
        
         hardeningDisable = [ "format" "pie" ]

     
···

       74
       74
        
             name = "CVE-2022-28391.patch";

     

       75
       75
        
             url = "https://git.alpinelinux.org/aports/plain/main/busybox/0002-nslookup-sanitize-all-printed-strings-with-printable.patch?id=ed92963eb55bbc8d938097b9ccb3e221a94653f4";

     

       76
       76
        
             sha256 = "sha256-vl1wPbsHtXY9naajjnTicQ7Uj3N+EQ8pRNnrdsiow+w=";

     

       77
       77
       -
           })

     

       78
       78
       -
           (fetchurl {

     

       79
       79
       -
             name = "CVE-2022-30065.patch";

     

       80
       80
       -
             url = "https://git.alpinelinux.org/aports/plain/main/busybox/CVE-2022-30065.patch?id=4ffd996b3f8298c7dd424b912c245864c816e354";

     

       81
       81
       -
             sha256 = "sha256-+WSYxI6eF8S0tya/S62f9Nc6jVMnHO0q1OyM69GlNTY=";

     

       82
       77
        
           })

     

       83
       78
        
         ] ++ lib.optional (stdenv.hostPlatform != stdenv.buildPlatform) ./clang-cross.patch;

     

       84
       79

+2 -2

pkgs/os-specific/linux/iotop-c/default.nix

···

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation rec {

     

       4
       4
        
         pname = "iotop-c";

     

       5
       5
       -
         version = "1.22";

     

       5
       5
       +
         version = "1.23";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "Tomas-M";

     

       9
       9
        
           repo = "iotop";

     

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

     

       11
       11
       -
           sha256 = "sha256-MHjG14vZsuDrR9/SLotb7Uc3RW8Np9E2X0GXkSM+RxE=";

     

       11
       11
       +
           sha256 = "sha256-4DTYtUltmZ+nkm4ZLac+6JbBW3z+qby7sP33LwEXtcQ=";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         nativeBuildInputs = [ pkg-config ];

+2 -2

pkgs/os-specific/linux/kernel/linux-5.10.nix

···

       3
       3
        
       with lib;

     

       4
       4
        
       

     

       5
       5
        
       buildLinux (args // rec {

     

       6
       6
       -
         version = "5.10.165";

     

       6
       6
       +
         version = "5.10.166";

     

       7
       7
        
       

     

       8
       8
        
         # modDirVersion needs to be x.y.z, will automatically add .0 if needed

     

       9
       9
        
         modDirVersion = versions.pad 3 version;

     
···

       13
       13
        
       

     

       14
       14
        
         src = fetchurl {

     

       15
       15
        
           url = "mirror://kernel/linux/kernel/v5.x/linux-${version}.tar.xz";

     

       16
       16
       -
           sha256 = "03dg8yx0gdzm8zbwd1f9jn4c5jhr8qilhjzxgwm0mv8riz2fy7cp";

     

       16
       16
       +
           sha256 = "1bz1sgkqniwg84wv9vcg08mksa5q533vgynsd3y0xnjv1rwa2l80";

     

       17
       17
        
         };

     

       18
       18
        
       } // (args.argsOverride or {}))

+2 -2

pkgs/os-specific/linux/kernel/linux-5.15.nix

···

       3
       3
        
       with lib;

     

       4
       4
        
       

     

       5
       5
        
       buildLinux (args // rec {

     

       6
       6
       -
         version = "5.15.90";

     

       6
       6
       +
         version = "5.15.91";

     

       7
       7
        
       

     

       8
       8
        
         # modDirVersion needs to be x.y.z, will automatically add .0 if needed

     

       9
       9
        
         modDirVersion = versions.pad 3 version;

     
···

       13
       13
        
       

     

       14
       14
        
         src = fetchurl {

     

       15
       15
        
           url = "mirror://kernel/linux/kernel/v5.x/linux-${version}.tar.xz";

     

       16
       16
       -
           sha256 = "0hiv74mxkp3v04lphnyw16akgavaz527bzhnfnpm6rv848047zg6";

     

       16
       16
       +
           sha256 = "107yw7mibibhfrggm8idzn5bayjvkxaq1kv3kkm1lpxipsqjng56";

     

       17
       17
        
         };

     

       18
       18
        
       } // (args.argsOverride or { }))

+2 -2

pkgs/os-specific/linux/kernel/linux-6.1.nix

···

       3
       3
        
       with lib;

     

       4
       4
        
       

     

       5
       5
        
       buildLinux (args // rec {

     

       6
       6
       -
         version = "6.1.8";

     

       6
       6
       +
         version = "6.1.9";

     

       7
       7
        
       

     

       8
       8
        
         # modDirVersion needs to be x.y.z, will automatically add .0 if needed

     

       9
       9
        
         modDirVersion = versions.pad 3 version;

     
···

       13
       13
        
       

     

       14
       14
        
         src = fetchurl {

     

       15
       15
        
           url = "mirror://kernel/linux/kernel/v6.x/linux-${version}.tar.xz";

     

       16
       16
       -
           sha256 = "0vc1ggjy4wvna7g6xgbjzhk93whssj9ixcal0hkhldxsp0xba2xn";

     

       16
       16
       +
           sha256 = "0awjynyy049px0h7li59w3zgn3z39alv6glzrmx6wf1wd62z236n";

     

       17
       17
        
         };

     

       18
       18
        
       } // (args.argsOverride or { }))

+3 -3

pkgs/os-specific/linux/kernel/linux-rt-5.10.nix

···

       6
       6
        
       , ... } @ args:

     

       7
       7
        
       

     

       8
       8
        
       let

     

       9
       9
       -
         version = "5.10.162-rt78"; # updated by ./update-rt.sh

     

       9
       9
       +
         version = "5.10.165-rt81"; # updated by ./update-rt.sh

     

       10
       10
        
         branch = lib.versions.majorMinor version;

     

       11
       11
        
         kversion = builtins.elemAt (lib.splitString "-" version) 0;

     

       12
       12
        
       in buildLinux (args // {

     
···

       17
       17
        
       

     

       18
       18
        
         src = fetchurl {

     

       19
       19
        
           url = "mirror://kernel/linux/kernel/v5.x/linux-${kversion}.tar.xz";

     

       20
       20
       -
           sha256 = "05yjgp1la5flwqji9b6j7nbdgg5fwzv2ph536v4f9pzza3y01i1f";

     

       20
       20
       +
           sha256 = "03dg8yx0gdzm8zbwd1f9jn4c5jhr8qilhjzxgwm0mv8riz2fy7cp";

     

       21
       21
        
         };

     

       22
       22
        
       

     

       23
       23
        
         kernelPatches = let rt-patch = {

     

       24
       24
        
           name = "rt";

     

       25
       25
        
           patch = fetchurl {

     

       26
       26
        
             url = "mirror://kernel/linux/kernel/projects/rt/${branch}/older/patch-${version}.patch.xz";

     

       27
       27
       -
             sha256 = "146y62kzxm0d7bw8riqds0m8iilx3zd6yh5dfxr5q90jcjnah16x";

     

       27
       27
       +
             sha256 = "1441lwmz4v427gcyddps17ms96y86klmnlw95kc74j6wmy387fcg";

     

       28
       28
        
           };

     

       29
       29
        
         }; in [ rt-patch ] ++ kernelPatches;

     

       30
       30

+5 -6

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

···

       3
       3
        
       , libyamlcpp, nlohmann_json, re2

     

       4
       4
        
       }:

     

       5
       5
        
       

     

       6
       6
       -
       with lib;

     

       7
       6
        
       let

     

       8
       7
        
         # Compare with https://github.com/draios/sysdig/blob/dev/cmake/modules/falcosecurity-libs.cmake

     

       9
       8
        
         libsRev = "0.9.1";

     
···

       54
       53
        
           libyamlcpp

     

       55
       54
        
           jsoncpp

     

       56
       55
        
           nlohmann_json

     

       57
       57
       -
         ] ++ optionals (kernel != null) kernel.moduleBuildDependencies;

     

       56
       56
       +
         ] ++ lib.optionals (kernel != null) kernel.moduleBuildDependencies;

     

       58
       57
        
       

     

       59
       58
        
         hardeningDisable = [ "pic" ];

     

       60
       59
        
       

     
···

       82
       81
        
           "-DUSE_BUNDLED_TBB=OFF"

     

       83
       82
        
           "-DUSE_BUNDLED_RE2=OFF"

     

       84
       83
        
           "-DCREATE_TEST_TARGETS=OFF"

     

       85
       85
       -
         ] ++ optional (kernel == null) "-DBUILD_DRIVER=OFF";

     

       84
       84
       +
         ] ++ lib.optional (kernel == null) "-DBUILD_DRIVER=OFF";

     

       86
       85
        
       

     

       87
       86
        
         # needed since luajit-2.1.0-beta3

     

       88
       87
        
         NIX_CFLAGS_COMPILE = "-DluaL_reg=luaL_Reg -DluaL_getn(L,i)=((int)lua_objlen(L,i))";

     
···

       93
       92
        
             exit 1

     

       94
       93
        
           fi

     

       95
       94
        
           cmakeFlagsArray+=(-DCMAKE_EXE_LINKER_FLAGS="-ltbb -lcurl -labsl_synchronization")

     

       96
       96
       -
         '' + optionalString (kernel != null) ''

     

       95
       95
       +
         '' + lib.optionalString (kernel != null) ''

     

       97
       96
        
           export INSTALL_MOD_PATH="$out"

     

       98
       97
        
           export KERNELDIR="${kernel.dev}/lib/modules/${kernel.modDirVersion}/build"

     

       99
       98
        
         '';

     
···

       106
       105
        
             rmdir $out/etc/bash_completion.d

     

       107
       106
        
             rmdir $out/etc

     

       108
       107
        
           ''

     

       109
       109
       -
           + optionalString (kernel != null) ''

     

       108
       108
       +
           + lib.optionalString (kernel != null) ''

     

       110
       109
        
             make install_driver

     

       111
       110
        
             kernel_dev=${kernel.dev}

     

       112
       111
        
             kernel_dev=''${kernel_dev#/nix/store/}

     
···

       121
       120
        
           '';

     

       122
       121
        
       

     

       123
       122
        
       

     

       124
       124
       -
         meta = {

     

       123
       123
       +
         meta = with lib; {

     

       125
       124
        
           description = "A tracepoint-based system tracing tool for Linux (with clients for other OSes)";

     

       126
       125
        
           license = with licenses; [ asl20 gpl2 mit ];

     

       127
       126
        
           maintainers = [maintainers.raskin];

+3 -3

pkgs/servers/consul/default.nix

···

       2
       2
        
       

     

       3
       3
        
       buildGoModule rec {

     

       4
       4
        
         pname = "consul";

     

       5
       5
       -
         version = "1.14.3";

     

       5
       5
       +
         version = "1.14.4";

     

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

     

       7
       7
        
       

     

       8
       8
        
         # Note: Currently only release tags are supported, because they have the Consul UI

     
···

       17
       17
        
           owner = "hashicorp";

     

       18
       18
        
           repo = pname;

     

       19
       19
        
           inherit rev;

     

       20
       20
       -
           sha256 = "sha256-zTsFLBd+7G+8HT8EGLSQaMhFfh/7s1tfu2gZtIMbkDs=";

     

       20
       20
       +
           sha256 = "sha256-aPJcb7nIjNIT5Bt/On+KFHHA2bNBO4y7HDFpsjhh8j0=";

     

       21
       21
        
         };

     

       22
       22
        
       

     

       23
       23
        
         passthru.tests.consul = nixosTests.consul;

     
···

       26
       26
        
         # has a split module structure in one repo

     

       27
       27
        
         subPackages = ["." "connect/certgen"];

     

       28
       28
        
       

     

       29
       29
       -
         vendorSha256 = "sha256-tekrveDmUq6qYafRMm7knxp9+FevaDbu4DZusO6KDtA=";

     

       29
       29
       +
         vendorHash = "sha256-g7Pi/wOjClwcuqeHQjhqBtnORArx1G4Znqvfl0bf3V4=";

     

       30
       30
        
       

     

       31
       31
        
         doCheck = false;

     

       32
       32

+2 -10

pkgs/servers/hqplayerd/default.nix

···

       28
       28
        
       in

     

       29
       29
        
       stdenv.mkDerivation rec {

     

       30
       30
        
         pname = "hqplayerd";

     

       31
       31
       -
         version = "4.33.0-96sse42";

     

       31
       31
       +
         version = "4.34.0-100sse42";

     

       32
       32
        
       

     

       33
       33
        
         src = fetchurl {

     

       34
       34
        
           url = "https://www.signalyst.eu/bins/${pname}/fc36/${pname}-${version}.fc36.x86_64.rpm";

     

       35
       35
       -
           hash = "sha256-4gPK31XMd5JUp2+il1Qa7r0EaXVGEvKoYLNGSD2dLUs=";

     

       35
       35
       +
           hash = "sha256-MCRZ0XKi6pztVTuPQpPEn6wHsOwtSxR0Px9r12jnC9U=";

     

       36
       36
        
         };

     

       37
       37
        
       

     

       38
       38
        
         unpackPhase = ''

     
···

       75
       75
        
           # configuration

     

       76
       76
        
           mkdir -p $out/etc

     

       77
       77
        
           cp -rv ./etc/hqplayer $out/etc/

     

       78
       78
       -
       

     

       79
       79
       -
           # udev rules

     

       80
       80
       -
           mkdir -p $out/etc/udev

     

       81
       81
       -
           cp -rv ./etc/udev/rules.d $out/etc/udev/

     

       82
       82
       -
       

     

       83
       83
       -
           # kernel module cfgs

     

       84
       84
       -
           mkdir -p $out/etc

     

       85
       85
       -
           cp -rv ./etc/modules-load.d $out/etc/

     

       86
       78
        
       

     

       87
       79
        
           # systemd service file

     

       88
       80
        
           mkdir -p $out/lib/systemd

+24

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

···

       1
       1
       +
       { lib, buildGoModule, fetchFromGitHub, nixosTests }:

     

       2
       2
       +
       

     

       3
       3
       +
       buildGoModule rec {

     

       4
       4
       +
         pname = "shelly_exporter";

     

       5
       5
       +
         version = "1.0.0";

     

       6
       6
       +
       

     

       7
       7
       +
         src = fetchFromGitHub {

     

       8
       8
       +
           owner = "aexel90";

     

       9
       9
       +
           repo = pname;

     

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

     

       11
       11
       +
           sha256 = "sha256-L0TuBDq5eEahQvzqd1WuvmXuQbbblCM+Nvj15IybnVo=";

     

       12
       12
       +
         };

     

       13
       13
       +
       

     

       14
       14
       +
         vendorSha256 = "sha256-BCrge2xLT4b4wpYA+zcsH64a/nfV8+HeZF7L49p2gEw=";

     

       15
       15
       +
       

     

       16
       16
       +
         passthru.tests = { inherit (nixosTests.prometheus-exporters) shelly; };

     

       17
       17
       +
       

     

       18
       18
       +
         meta = with lib; {

     

       19
       19
       +
           description = "Shelly humidity sensor exporter for prometheus";

     

       20
       20
       +
           homepage = "https://github.com/aexel90/shelly_exporter";

     

       21
       21
       +
           license = licenses.asl20;

     

       22
       22
       +
           maintainers = with maintainers; [drupol];

     

       23
       23
       +
         };

     

       24
       24
       +
       }

+4 -4

pkgs/servers/prowlarr/default.nix

···

       16
       16
        
         }."${stdenv.hostPlatform.system}" or (throw "Unsupported system: ${stdenv.hostPlatform.system}");

     

       17
       17
        
       

     

       18
       18
        
         hash = {

     

       19
       19
       -
           x64-linux_hash = "sha256-w9je2dcVMDhUCG2zK9uQWpTXQh3zw+0yL/qVrl3DqzE=";

     

       20
       20
       -
           arm64-linux_hash = "sha256-j5pxMTLE2Mk91q76Y1n8j3pG/1aPrGkkvSjzAI8nJro=";

     

       21
       21
       -
           x64-osx_hash = "sha256-ILz3zNQNUwFGMLvz4sqZMzsN+tw/HNpr5mFLSIKQ4Gg=";

     

       19
       19
       +
           x64-linux_hash = "sha256-0JeZaHaAJ0Z+wcEPGA8yidiKsU/lxEgC6BGpFEzjO0A=";

     

       20
       20
       +
           arm64-linux_hash = "sha256-/N8SY0JS3yX2MARb7MN68CWEZQ8mIXM5zmg96r8hVsw=";

     

       21
       21
       +
           x64-osx_hash = "sha256-kcD6ATOGYJULk6g+v4uISDtnzr0c1y2BntIt3MWUR0Q=";

     

       22
       22
        
         }."${arch}-${os}_hash";

     

       23
       23
        
       

     

       24
       24
        
       in stdenv.mkDerivation rec {

     

       25
       25
        
         pname = "prowlarr";

     

       26
       26
       -
         version = "1.1.1.2377";

     

       26
       26
       +
         version = "1.1.2.2453";

     

       27
       27
        
       

     

       28
       28
        
         src = fetchurl {

     

       29
       29
        
           url = "https://github.com/Prowlarr/Prowlarr/releases/download/v${version}/Prowlarr.develop.${version}.${os}-core-${arch}.tar.gz";

+2 -2

pkgs/servers/roon-server/default.nix

···

       15
       15
        
       , stdenv

     

       16
       16
        
       }:

     

       17
       17
        
       let

     

       18
       18
       -
         version = "2.0-1193";

     

       18
       18
       +
         version = "2.0-1202";

     

       19
       19
        
         urlVersion = builtins.replaceStrings [ "." "-" ] [ "00" "0" ] version;

     

       20
       20
        
       in

     

       21
       21
        
       stdenv.mkDerivation {

     
···

       24
       24
        
       

     

       25
       25
        
         src = fetchurl {

     

       26
       26
        
           url = "https://download.roonlabs.com/updates/production/RoonServer_linuxx64_${urlVersion}.tar.bz2";

     

       27
       27
       -
           hash = "sha256-yvM4mEFBelT8Nox0vzI4tlQbxDUkoMAB6q8l5LW8+b4=";

     

       27
       27
       +
           hash = "sha256-YeBzXnw/BpJDUJ7fUf7TH0zQcpCjUm9peB7zPO2ZsYI=";

     

       28
       28
        
         };

     

       29
       29
        
       

     

       30
       30
        
         dontConfigure = true;

+3 -3

pkgs/servers/rtsp-simple-server/default.nix

···

       5
       5
        
       

     

       6
       6
        
       buildGoModule rec {

     

       7
       7
        
         pname = "rtsp-simple-server";

     

       8
       8
       -
         version = "0.21.1";

     

       8
       8
       +
         version = "0.21.2";

     

       9
       9
        
       

     

       10
       10
        
         src = fetchFromGitHub {

     

       11
       11
        
           owner = "aler9";

     

       12
       12
        
           repo = pname;

     

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

     

       14
       14
       -
           hash = "sha256-hYO/MMZBb9YczvIq4mn1XE9rhnaTg9t35by/GHtvdJQ=";

     

       14
       14
       +
           hash = "sha256-dg+Xl3yHiWJPV+3iFcMVCPHOpHo0+pFiJv+ZVXDAK6k=";

     

       15
       15
        
         };

     

       16
       16
        
       

     

       17
       17
       -
         vendorHash = "sha256-Q1zeKGu20kOpjqdLCB7stuWBqi/2EyWK7vMRAYUCJKg=";

     

       17
       17
       +
         vendorHash = "sha256-KvG0+wxe0D+TxQmxaskTa228zUlOxCZE9rGqMYkdwzM=";

     

       18
       18
        
       

     

       19
       19
        
         # Tests need docker

     

       20
       20
        
         doCheck = false;

+2 -2

pkgs/servers/uxplay/default.nix

···

       13
       13
        
       

     

       14
       14
        
       stdenv.mkDerivation rec {

     

       15
       15
        
         pname = "uxplay";

     

       16
       16
       -
         version = "1.61.1";

     

       16
       16
       +
         version = "1.62";

     

       17
       17
        
       

     

       18
       18
        
         src = fetchFromGitHub {

     

       19
       19
        
           owner = "FDH2";

     

       20
       20
        
           repo = "UxPlay";

     

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

     

       22
       22
       -
           sha256 = "sha256-eLTIpRmKewBghUYFot8I3iTeiI6wlU7WNs8/X3w+U80=";

     

       22
       22
       +
           sha256 = "sha256-+IO+ITSa5LSFdCaU28B/MMBl4a+35957VlNxIQK5IqU=";

     

       23
       23
        
         };

     

       24
       24
        
       

     

       25
       25
        
         postPatch = ''

+6 -2

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

···

       16
       16
        
       

     

       17
       17
        
       let

     

       18
       18
        
         pname = "wallabag";

     

       19
       19
       -
         version = "2.5.2";

     

       19
       19
       +
         version = "2.5.3";

     

       20
       20
        
       in

     

       21
       21
        
       stdenv.mkDerivation {

     

       22
       22
        
         inherit pname version;

     
···

       27
       27
        
             "https://static.wallabag.org/releases/wallabag-release-${version}.tar.gz"

     

       28
       28
        
             "https://github.com/wallabag/wallabag/releases/download/${version}/wallabag-${version}.tar.gz"

     

       29
       29
        
           ];

     

       30
       30
       -
           hash = "sha256-Q989SorGPm3KBuQhGAinYU6HGIa9RrhtRPvwGALU6jk=";

     

       30
       30
       +
           hash = "sha256-a30z9rdXcfc2eVuShEobgDWWHr9TfMwq9WwaWdrI3QU=";

     

       31
       31
        
         };

     

       32
       32
        
       

     

       33
       33
        
         patches = [

     
···

       45
       45
        
         dontBuild = true;

     

       46
       46
        
       

     

       47
       47
        
         installPhase = ''

     

       48
       48
       +
           runHook preInstall

     

       49
       49
       +
       

     

       48
       50
        
           mkdir $out

     

       49
       51
        
           cp -R * $out/

     

       52
       52
       +
       

     

       53
       53
       +
           runHook postInstall

     

       50
       54
        
         '';

     

       51
       55
        
       

     

       52
       56
        
         meta = with lib; {

+3 -3

pkgs/servers/zigbee2mqtt/default.nix

···

       8
       8
        
       

     

       9
       9
        
       buildNpmPackage rec {

     

       10
       10
        
         pname = "zigbee2mqtt";

     

       11
       11
       -
         version = "1.29.2";

     

       11
       11
       +
         version = "1.30.0";

     

       12
       12
        
       

     

       13
       13
        
         src = fetchFromGitHub {

     

       14
       14
        
           owner = "Koenkk";

     

       15
       15
        
           repo = "zigbee2mqtt";

     

       16
       16
        
           rev = version;

     

       17
       17
       -
           hash = "sha256-f3M5QgSN7j/zfKAmJiAPGSEa2pS77zJKUamQrZMllYY=";

     

       17
       17
       +
           hash = "sha256-BmkSpl+6aUTiueB9VILOcmJM+tCxK2NbqJvJYfoyvBo=";

     

       18
       18
        
         };

     

       19
       19
        
       

     

       20
       20
       -
         npmDepsHash = "sha256-cVX26bshHNOAPVhJQ3G88orrqQvxsF3FnR3/TNVZZJY=";

     

       20
       20
       +
         npmDepsHash = "sha256-ZrUbn/6hbbBRng+TJG6cxBUJ4Td4/P6MoeKVkInPmb4=";

     

       21
       21
        
       

     

       22
       22
        
         nativeBuildInputs = [

     

       23
       23
        
           python3

+3 -3

pkgs/shells/carapace/default.nix

···

       2
       2
        
       

     

       3
       3
        
       buildGoModule rec {

     

       4
       4
        
         pname = "carapace";

     

       5
       5
       -
         version = "0.20.2";

     

       5
       5
       +
         version = "0.21.0";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "rsteube";

     

       9
       9
        
           repo = "${pname}-bin";

     

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

     

       11
       11
       -
           sha256 = "sha256-UPm0B3sv2+0/tS7NdqY5fpvMbI9B7CxixWF9M74H5w0=";

     

       11
       11
       +
           sha256 = "sha256-vpYBgDX0CxTNphmdwrI56AtlPlf2DGf3BZ+jWwdanpw=";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
       -
         vendorHash = "sha256-l4DG6sZyFqu4OlxxL6mmcXTGljxY7xk5u5QlOr8dBNI=";

     

       14
       14
       +
         vendorHash = "sha256-Qi2fkAdO0clpKowSdoxyanIB65oagqEnw5gCqVHPJb0=";

     

       15
       15
        
       

     

       16
       16
        
         subPackages = [ "./cmd/carapace" ];

     

       17
       17

+5 -17

pkgs/shells/zsh/nix-zsh-completions/default.nix

···

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation rec {

     

       4
       4
        
         pname = "nix-zsh-completions";

     

       5
       5
       -
         version = "0.4.4";

     

       5
       5
       +
         version = "unstable-2023-01-30";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
       -
           owner = "spwhitt";

     

       8
       8
       +
           owner = "nix-community";

     

       9
       9
        
           repo = "nix-zsh-completions";

     

       10
       10
       -
           rev = version;

     

       11
       11
       -
           sha256 = "1n9whlys95k4wc57cnz3n07p7zpkv796qkmn68a50ygkx6h3afqf";

     

       10
       10
       +
           rev = "6a1bfc024481bdba568f2ced65e02f3a359a7692";

     

       11
       11
       +
           hash = "sha256-aXetjkl5nPuYHHyuX59ywXF+4Xg+PUCV6Y2u+g18gEk=";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
       -
         # https://github.com/spwhitt/nix-zsh-completions/issues/42

     

       15
       15
       -
         #

     

       16
       16
       -
         # _nix completion is broken. Remove it; _nix provided by the nix

     

       17
       17
       -
         # package will be used instead. It is not sufficient to set low

     

       18
       18
       -
         # meta.priority below if nix is installed in the system profile and

     

       19
       19
       -
         # nix-zsh-completions in an user profile. In that case, the broken

     

       20
       20
       -
         # version takes precedence over the good one.

     

       21
       21
       -
         postPatch = ''

     

       22
       22
       -
           rm _nix

     

       23
       23
       -
         '';

     

       24
       24
       -
       

     

       25
       14
        
         strictDeps = true;

     

       26
       15
        
         installPhase = ''

     

       27
       16
        
           mkdir -p $out/share/zsh/{site-functions,plugins/nix}

     
···

       30
       19
        
         '';

     

       31
       20
        
       

     

       32
       21
        
         meta = with lib; {

     

       33
       33
       -
           homepage = "https://github.com/spwhitt/nix-zsh-completions";

     

       22
       22
       +
           homepage = "https://github.com/nix-community/nix-zsh-completions";

     

       34
       23
        
           description = "ZSH completions for Nix, NixOS, and NixOps";

     

       35
       35
       -
           priority = 6; # prevent collisions with nix 2.4's built-in completions

     

       36
       24
        
           license = licenses.bsd3;

     

       37
       25
        
           platforms = platforms.all;

     

       38
       26
        
           maintainers = with maintainers; [ spwhitt olejorgenb hedning ma27 ];

+2 -2

pkgs/tools/graphics/glmark2/default.nix

···

       19
       19
        
       

     

       20
       20
        
       stdenv.mkDerivation rec {

     

       21
       21
        
         pname = "glmark2";

     

       22
       22
       -
         version = "2021.12";

     

       22
       22
       +
         version = "2023.01";

     

       23
       23
        
       

     

       24
       24
        
         src = fetchFromGitHub {

     

       25
       25
        
           owner = "glmark2";

     

       26
       26
        
           repo = "glmark2";

     

       27
       27
        
           rev = version;

     

       28
       28
       -
           sha256 = "sha256-S6KkazkG+kdx02MPwrYvCFWSOtM6t5xT0OTE9PLCzas=";

     

       28
       28
       +
           sha256 = "sha256-WCvc5GqrAdpIKQ4LVqwO6ZGbzBgLCl49NxiGJynIjSQ=";

     

       29
       29
        
         };

     

       30
       30
        
       

     

       31
       31
        
         nativeBuildInputs = [ pkg-config wafHook makeWrapper ];

+3 -6

pkgs/tools/inputmethods/skk/skk-dicts/default.nix

···

       1
       1
       -
       { lib, stdenv, fetchurl, buildPackages, libiconv, skktools }:

     

       1
       1
       +
       { lib, stdenv, fetchurl, buildPackages, iconv, skktools }:

     

       2
       2
        
       

     

       3
       3
        
       let

     

       4
       4
        
         # kana to kanji

     
···

       25
       25
        
           url = "https://raw.githubusercontent.com/skk-dev/dict/8b35d07a7d2044d48b063d2774d9f9d00bb7cb48/SKK-JISYO.assoc";

     

       26
       26
        
           sha256 = "1smcbyv6srrhnpl7ic9nqds9nz3g2dgqngmhzkrdlwmvcpvakp1v";

     

       27
       27
        
         };

     

       28
       28
       -
       

     

       29
       29
       -
         iconvBin = if stdenv.isDarwin then libiconv else  buildPackages.stdenv.cc.libc;

     

       30
       28
        
       in

     

       31
       29
        
       

     

       32
       30
        
       stdenv.mkDerivation {

     

       33
       31
        
         pname = "skk-dicts-unstable";

     

       34
       32
        
         version = "2020-03-24";

     

       35
       33
        
         srcs = [ small medium large edict assoc ];

     

       36
       36
       -
         nativeBuildInputs = [ skktools ] ++ lib.optional stdenv.isDarwin libiconv;

     

       34
       34
       +
         nativeBuildInputs = [ iconv skktools ];

     

       37
       35
        
       

     

       38
       36
        
         strictDeps = true;

     

       39
       37
        
       

     
···

       51
       49
        
           for src in $srcs; do

     

       52
       50
        
             dst=$out/share/$(dictname $src)

     

       53
       51
        
             echo ";;; -*- coding: utf-8 -*-" > $dst  # libskk requires this on the first line

     

       54
       54
       -
             ${lib.getBin iconvBin}/bin/iconv \

     

       55
       55
       -
               -f EUC-JP -t UTF-8 $src | skkdic-expr2 >> $dst

     

       52
       52
       +
             iconv -f EUC-JP -t UTF-8 $src | skkdic-expr2 >> $dst

     

       56
       53
        
           done

     

       57
       54
        
       

     

       58
       55
        
           # combine .L .edict and .assoc for convenience

+11 -4

pkgs/tools/misc/dust/default.nix

···

       1
       1
       -
       { stdenv, lib, fetchFromGitHub, rustPlatform, AppKit }:

     

       1
       1
       +
       { stdenv, lib, fetchFromGitHub, rustPlatform, AppKit, installShellFiles }:

     

       2
       2
        
       

     

       3
       3
        
       rustPlatform.buildRustPackage rec {

     

       4
       4
        
         pname = "du-dust";

     

       5
       5
       -
         version = "0.8.3";

     

       5
       5
       +
         version = "0.8.4";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "bootandy";

     

       9
       9
        
           repo = "dust";

     

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

     

       11
       11
       -
           sha256 = "sha256-+YcHiW4kR4JeIY6zv1WJ97dCIakvtbn8+b9tLFH+aLE=";

     

       11
       11
       +
           sha256 = "sha256-g1i003nBbTYIuKG4ZCQSoI8gINTVc8BKRoO3UOeHOGE=";

     

       12
       12
        
           # Remove unicode file names which leads to different checksums on HFS+

     

       13
       13
        
           # vs. other filesystems because of unicode normalisation.

     

       14
       14
        
           postFetch = ''

     
···

       16
       16
        
           '';

     

       17
       17
        
         };

     

       18
       18
        
       

     

       19
       19
       -
         cargoSha256 = "sha256-yKj9CBoEC6UJf4L+XO2qi69//45lSqblMe8ofnLctEw=";

     

       19
       19
       +
         cargoHash = "sha256-jtQ/nkD5XMD2rsq550XsRK416wOCR3OuhgGPeuC3jzc=";

     

       20
       20
       +
       

     

       21
       21
       +
         nativeBuildInputs = [ installShellFiles ];

     

       20
       22
        
       

     

       21
       23
        
         buildInputs = lib.optionals stdenv.isDarwin [ AppKit ];

     

       22
       24
        
       

     

       23
       25
        
         doCheck = false;

     

       26
       26
       +
       

     

       27
       27
       +
         postInstall = ''

     

       28
       28
       +
           installManPage man-page/dust.1

     

       29
       29
       +
           installShellCompletion completions/dust.{bash,fish} --zsh completions/_dust

     

       30
       30
       +
         '';

     

       24
       31
        
       

     

       25
       32
        
         meta = with lib; {

     

       26
       33
        
           description = "du + rust = dust. Like du but more intuitive";

+3 -3

pkgs/tools/misc/fclones/default.nix

···

       8
       8
        
       

     

       9
       9
        
       rustPlatform.buildRustPackage rec {

     

       10
       10
        
         pname = "fclones";

     

       11
       11
       -
         version = "0.29.1";

     

       11
       11
       +
         version = "0.29.3";

     

       12
       12
        
       

     

       13
       13
        
         src = fetchFromGitHub {

     

       14
       14
        
           owner = "pkolaczk";

     

       15
       15
        
           repo = pname;

     

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

     

       17
       17
       -
           sha256 = "sha256-spWfZx2br7gSLS0xaUBvMgvA326ISh16i/s0K3m1HCI=";

     

       17
       17
       +
           sha256 = "sha256-dz7Mxi5KIZYw0oLic50hNT6rWbQpfiBE4hlZsxNfKsA=";

     

       18
       18
        
         };

     

       19
       19
        
       

     

       20
       20
       -
         cargoSha256 = "sha256-qwjwauM2ejeMEbajVD8Deuhl/qMcB7MsvjR2CYGaF+M=";

     

       20
       20
       +
         cargoHash = "sha256-I9pd+Q3b++ujynfpZq88lqPSUOc/SXWpNzR/CwtNEPA=";

     

       21
       21
        
       

     

       22
       22
        
         buildInputs = lib.optionals stdenv.isDarwin [

     

       23
       23
        
           AppKit

+3 -3

pkgs/tools/misc/iam-policy-json-to-terraform/default.nix

···

       2
       2
        
       

     

       3
       3
        
       buildGoModule rec {

     

       4
       4
        
         pname = "iam-policy-json-to-terraform";

     

       5
       5
       -
         version = "1.8.1";

     

       5
       5
       +
         version = "1.8.2";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "flosell";

     

       9
       9
        
           repo = pname;

     

       10
       10
        
           rev = "${version}";

     

       11
       11
       -
           sha256 = "sha256-O3JlBWT2YVu3mv/BCbs65k7HMF4cRCihd59wZzeoxcI=";

     

       11
       11
       +
           sha256 = "sha256-ovmWZpeHt1L8zNzG7+2BohteSjpYADMivi+AP0Vm8/E=";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
       -
         vendorSha256 = "sha256-IXWt/yFapDamfZClI6gm5vPA5VW2gV2iEq5c/nJXiiA=";

     

       14
       14
       +
         vendorHash = "sha256-1WTc7peTJI3IvHJqznqRz29uQ2NG0CZpAAzlyYymZCQ=";

     

       15
       15
        
       

     

       16
       16
        
         meta = with lib; {

     

       17
       17
        
           description = "Small tool to convert an IAM Policy in JSON format into a Terraform aws_iam_policy_document ";

+1

pkgs/tools/misc/lbdb/default.nix

···

       15
       15
        
         perl' = perl.withPackages (p: with p; [

     

       16
       16
        
           AuthenSASL

     

       17
       17
        
           ConvertASN1

     

       18
       18
       +
           IOSocketSSL

     

       18
       19
        
           perlldap

     

       19
       20
        
         ]);

     

       20
       21
        
       in

+2 -2

pkgs/tools/misc/plantuml-server/default.nix

···

       1
       1
        
       { lib, stdenv, fetchurl }:

     

       2
       2
        
       

     

       3
       3
        
       let

     

       4
       4
       -
         version = "1.2023.0";

     

       4
       4
       +
         version = "1.2023.1";

     

       5
       5
        
       in

     

       6
       6
        
       stdenv.mkDerivation rec {

     

       7
       7
        
         pname = "plantuml-server";

     

       8
       8
        
         inherit version;

     

       9
       9
        
         src = fetchurl {

     

       10
       10
        
           url = "https://github.com/plantuml/plantuml-server/releases/download/v${version}/plantuml-v${version}.war";

     

       11
       11
       -
           sha256 = "sha256-FYyP6CZb+uarXlGEAPyt6KKvciZ5XsfjilDW0JObpDw=";

     

       11
       11
       +
           sha256 = "sha256-SaUk+gaMCpKF1HR9tpEhbZNmKV70LPHeH/YPsU8WGsU=";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         dontUnpack = true;

+2 -2

pkgs/tools/misc/wimboot/default.nix

···

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation rec {

     

       4
       4
        
         pname = "wimboot";

     

       5
       5
       -
         version = "2.7.4";

     

       5
       5
       +
         version = "2.7.5";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "ipxe";

     

       9
       9
        
           repo = "wimboot";

     

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

     

       11
       11
       -
           sha256 = "sha256-LaPH6nGQanweAG0niS75hr7zbO/9A3iZjS8wHD//oJ4=";

     

       11
       11
       +
           sha256 = "sha256-rbJONP3ge+2+WzCIpTUZeieQz9Q/MZfEUmQVbZ+9Dro=";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         sourceRoot = "source/src";

+3 -3

pkgs/tools/networking/mubeng/default.nix

···

       5
       5
        
       

     

       6
       6
        
       buildGoModule rec {

     

       7
       7
        
         pname = "mubeng";

     

       8
       8
       -
         version = "0.12.0-dev";

     

       8
       8
       +
         version = "0.13.0";

     

       9
       9
        
       

     

       10
       10
        
         src = fetchFromGitHub {

     

       11
       11
        
           owner = "kitabisa";

     

       12
       12
        
           repo = pname;

     

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

     

       14
       14
       -
           hash = "sha256-NBZmu0VcVUhJSdM3fzZ+4Q5oX8uxO6GLpEUq74x8HUU=";

     

       14
       14
       +
           hash = "sha256-FfqldK2iDB4Cy5M1uMUDEikV8JMMBzh2kgmvtZiJTOc=";

     

       15
       15
        
         };

     

       16
       16
        
       

     

       17
       17
       -
         vendorHash = "sha256-1JxyP6CrJ4/g7o3eGeN1kRXJU/jNLEB8fW1bjJytQqQ=";

     

       17
       17
       +
         vendorHash = "sha256-5YqourXzrRdfmWdHE/ZsRTze2h02ZHAsprQrSTZFrhY=";

     

       18
       18
        
       

     

       19
       19
        
         ldflags = [

     

       20
       20
        
           "-s"

+2 -2

pkgs/tools/networking/tgt/default.nix

···

       4
       4
        
       

     

       5
       5
        
       stdenv.mkDerivation rec {

     

       6
       6
        
         pname = "tgt";

     

       7
       7
       -
         version = "1.0.84";

     

       7
       7
       +
         version = "1.0.85";

     

       8
       8
        
       

     

       9
       9
        
         src = fetchFromGitHub {

     

       10
       10
        
           owner = "fujita";

     

       11
       11
        
           repo = pname;

     

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

     

       13
       13
       -
           sha256 = "sha256-NlEEakmut4WMI+mpm+SJOgHmWELRcl/dZJspks3VoqY=";

     

       13
       13
       +
           sha256 = "sha256-hjP+1uBcUfIFdRd0gbZXR+VsAF+6QrvV3//GrQhOKWc=";

     

       14
       14
        
         };

     

       15
       15
        
       

     

       16
       16
        
         nativeBuildInputs = [ libxslt docbook_xsl makeWrapper ];

+2 -2

pkgs/tools/security/cloudfox/default.nix

···

       5
       5
        
       

     

       6
       6
        
       buildGoModule rec {

     

       7
       7
        
         pname = "cloudfox";

     

       8
       8
       -
         version = "1.9.0";

     

       8
       8
       +
         version = "1.9.1";

     

       9
       9
        
       

     

       10
       10
        
         src = fetchFromGitHub {

     

       11
       11
        
           owner = "BishopFox";

     

       12
       12
        
           repo = pname;

     

       13
       13
        
           rev = "refs/tags/v${version}";

     

       14
       14
       -
           hash = "sha256-HLBW7a2sjA/bs8VJkwQNqM6YPEfa1onMoK89G5Fsb8s=";

     

       14
       14
       +
           hash = "sha256-TV2knPG5n5l8APeAmpDfu6vQLtEhjqH21JXAZLk0DDI=";

     

       15
       15
        
         };

     

       16
       16
        
       

     

       17
       17
        
         vendorHash = "sha256-xMHlooXuLECQi7co2/WvY0TIoV0S5OgcBklICCFk3ls=";

+2 -2

pkgs/tools/security/eid-mw/default.nix

···

       21
       21
        
       stdenv.mkDerivation rec {

     

       22
       22
        
         pname = "eid-mw";

     

       23
       23
        
         # NOTE: Don't just blindly update to the latest version/tag. Releases are always for a specific OS.

     

       24
       24
       -
         version = "5.1.4";

     

       24
       24
       +
         version = "5.1.9";

     

       25
       25
        
       

     

       26
       26
        
         src = fetchFromGitHub {

     

       27
       27
        
           owner = "Fedict";

     

       28
       28
        
           repo = "eid-mw";

     

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

     

       30
       30
       -
           sha256 = "pHzjLyQFn7UvFrPUcI/ZQHMOwVp6ndnX9YegJzlhERM=";

     

       30
       30
       +
           hash = "sha256-E7mNEgh8hujagqQe0ycEGcRDOlxVY7KzXw+DD8Wf9N8=";

     

       31
       31
        
         };

     

       32
       32
        
       

     

       33
       33
        
         nativeBuildInputs = [ autoreconfHook autoconf-archive pkg-config makeWrapper ];

+2 -2

pkgs/tools/security/proxmark3/proxmark3-rrg.nix

···

       7
       7
        
       

     

       8
       8
        
       mkDerivation rec {

     

       9
       9
        
         pname = "proxmark3-rrg";

     

       10
       10
       -
         version = "4.15864";

     

       10
       10
       +
         version = "4.16191";

     

       11
       11
        
       

     

       12
       12
        
         src = fetchFromGitHub {

     

       13
       13
        
           owner = "RfidResearchGroup";

     

       14
       14
        
           repo = "proxmark3";

     

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

     

       16
       16
       -
           sha256 = "sha256-vFebyXKC/vf8W8fGkTpSGTA0ZmfwnXSuuiOjV/u9240=";

     

       16
       16
       +
           sha256 = "sha256-l0aDp0s9ekUUHqkzGfVoSIf/4/GN2uiVGL/+QtKRCOs=";

     

       17
       17
        
         };

     

       18
       18
        
       

     

       19
       19
        
         nativeBuildInputs = [ pkg-config gcc-arm-embedded ];

+3 -3

pkgs/tools/security/teler/default.nix

···

       5
       5
        
       

     

       6
       6
        
       buildGoModule rec {

     

       7
       7
        
         pname = "teler";

     

       8
       8
       -
         version = "2.0.0-dev.2";

     

       8
       8
       +
         version = "2.0.0-dev.3";

     

       9
       9
        
       

     

       10
       10
        
         src = fetchFromGitHub {

     

       11
       11
        
           owner = "kitabisa";

     

       12
       12
        
           repo = "teler";

     

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

     

       14
       14
       -
           hash = "sha256-GlpQBmJ7HSKPFieM7E5NOnqGlUjQv9Ywe6XF5QIi+c4=";

     

       14
       14
       +
           hash = "sha256-2QrHxToHxHTjSl76q9A8fXCkOZkCwh1fu1h+HDUGsGA=";

     

       15
       15
        
         };

     

       16
       16
        
       

     

       17
       17
       -
         vendorHash = "sha256-g2YBMyLDGQZKxDBcZ1mca16jxODnJzcmMfFivBn6SdE=";

     

       17
       17
       +
         vendorHash = "sha256-gV/PJFcANeYTYUJG3PYNsApYaeBLx76+vVBvcuKDYO4=";

     

       18
       18
        
       

     

       19
       19
        
         ldflags = [

     

       20
       20
        
           "-s"

+3 -3

pkgs/tools/system/automatic-timezoned/default.nix

···

       5
       5
        
       

     

       6
       6
        
       rustPlatform.buildRustPackage rec {

     

       7
       7
        
         pname = "automatic-timezoned";

     

       8
       8
       -
         version = "1.0.60";

     

       8
       8
       +
         version = "1.0.61";

     

       9
       9
        
       

     

       10
       10
        
         src = fetchFromGitHub {

     

       11
       11
        
           owner = "maxbrunet";

     

       12
       12
        
           repo = pname;

     

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

     

       14
       14
       -
           sha256 = "sha256-6p9hLbU5ZaA4o6PRyfSt/gb3D3XeeWacJ2LlpJ0+w18=";

     

       14
       14
       +
           sha256 = "sha256-BAUvqRgcHVVFuTNX9W0PiYF3f1yd2mJxmE7It9as4gs=";

     

       15
       15
        
         };

     

       16
       16
        
       

     

       17
       17
       -
         cargoHash = "sha256-COWvEfFQMi3ltQSEFK3S6y07YLqqtjAf2H4p0TX/U70=";

     

       17
       17
       +
         cargoHash = "sha256-baQP9GEkZx5dSm64GpQ0h5SKQUzZALyplRUKEKX0K8U=";

     

       18
       18
        
       

     

       19
       19
        
         meta = with lib; {

     

       20
       20
        
           description = "Automatically update system timezone based on location";

+3 -3

pkgs/tools/system/systeroid/default.nix

···

       7
       7
        
       

     

       8
       8
        
       rustPlatform.buildRustPackage rec {

     

       9
       9
        
         pname = "systeroid";

     

       10
       10
       -
         version = "0.3.0";

     

       10
       10
       +
         version = "0.3.1";

     

       11
       11
        
       

     

       12
       12
        
         src = fetchFromGitHub {

     

       13
       13
        
           owner = "orhun";

     

       14
       14
        
           repo = pname;

     

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

     

       16
       16
       -
           sha256 = "sha256-VkkobNYkz8FunyaS6EJpfqOvDdwZJE+P2YTSJCgHZI0=";

     

       16
       16
       +
           sha256 = "sha256-uQa6n8DESnpO9xzfExywY6lG3nZkNSpjgEm5b+ayc8I=";

     

       17
       17
        
         };

     

       18
       18
        
       

     

       19
       19
        
         postPatch = ''

     
···

       21
       21
        
             --replace '"/usr/share/doc/kernel-doc-*/Documentation/*",' '"${linux-doc}/share/doc/linux-doc/*",'

     

       22
       22
        
         '';

     

       23
       23
        
       

     

       24
       24
       -
         cargoSha256 = "sha256-ulmU33j2edzMA/L4KXiM5M6RhH3MmMAkA2DuHxdj2uk=";

     

       24
       24
       +
         cargoHash = "sha256-baxXSjbS/5i9xnQGdPYPqgu0c2HGEAU7j7X8wtKSznA=";

     

       25
       25
        
       

     

       26
       26
        
         buildInputs = [

     

       27
       27
        
           xorg.libxcb

+6 -2

pkgs/tools/system/throttled/default.nix

···

       1
       1
       -
       { lib, stdenv, fetchFromGitHub, python3Packages }:

     

       1
       1
       +
       { lib, stdenv, fetchFromGitHub, python3Packages, pciutils }:

     

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation rec {

     

       4
       4
        
         pname = "throttled";

     
···

       20
       20
        
         ];

     

       21
       21
        
       

     

       22
       22
        
         # The upstream unit both assumes the install location, and tries to run in a virtualenv

     

       23
       23
       -
         postPatch = ''sed -e 's|ExecStart=.*|ExecStart=${placeholder "out"}/bin/throttled.py|' -i systemd/throttled.service'';

     

       23
       23
       +
         postPatch = ''

     

       24
       24
       +
           sed -e 's|ExecStart=.*|ExecStart=${placeholder "out"}/bin/throttled.py|' -i systemd/throttled.service

     

       25
       25
       +
       

     

       26
       26
       +
           substituteInPlace throttled.py --replace "'setpci'" "'${pciutils}/bin/setpci'"

     

       27
       27
       +
         '';

     

       24
       28
        
       

     

       25
       29
        
         installPhase = ''

     

       26
       30
        
           runHook preInstall

+2 -9

pkgs/tools/text/cmigemo/default.nix

···

       1
       1
        
       { lib, stdenv, fetchFromGitHub, buildPackages

     

       2
       2
       -
       , libiconv, nkf, perl, which

     

       2
       2
       +
       , iconv, nkf, perl, which

     

       3
       3
        
       , skk-dicts

     

       4
       4
        
       }:

     

       5
       5
        
       

     

       6
       6
       -
       let

     

       7
       7
       -
         iconvBin = if stdenv.isDarwin then libiconv else  buildPackages.stdenv.cc.libc;

     

       8
       8
       -
       in

     

       9
       6
        
       stdenv.mkDerivation {

     

       10
       7
        
         pname = "cmigemo";

     

       11
       8
        
         version = "1.3e";

     
···

       17
       14
        
           sha256 = "00a6kdmxp16b8x0p04ws050y39qspd1bqlfq74bkirc55b77a2m1";

     

       18
       15
        
         };

     

       19
       16
        
       

     

       20
       20
       -
         nativeBuildInputs = [ libiconv nkf perl which ];

     

       17
       17
       +
         nativeBuildInputs = [ iconv nkf perl which ];

     

       21
       18
        
       

     

       22
       19
        
         postUnpack = ''

     

       23
       20
        
           cp ${skk-dicts}/share/SKK-JISYO.L source/dict/

     
···

       26
       23
        
         patches = [ ./no-http-tool-check.patch ];

     

       27
       24
        
       

     

       28
       25
        
         makeFlags = [ "INSTALL=install" ];

     

       29
       29
       -
       

     

       30
       30
       -
         preBuild = ''

     

       31
       31
       -
           makeFlagsArray+=(FILTER_UTF8="${lib.getBin iconvBin}/bin/iconv -t utf-8 -f cp932")

     

       32
       32
       -
         '';

     

       33
       26
        
       

     

       34
       27
        
         buildFlags = [ (if stdenv.isDarwin then "osx-all" else "gcc-all") ];

     

       35
       28

+3 -3

pkgs/tools/text/mark/default.nix

···

       2
       2
        
       

     

       3
       3
        
       buildGoModule rec {

     

       4
       4
        
         pname = "mark";

     

       5
       5
       -
         version = "8.6";

     

       5
       5
       +
         version = "8.7";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner  = "kovetskiy";

     

       9
       9
        
           repo   = "mark";

     

       10
       10
        
           rev    = version;

     

       11
       11
       -
           sha256 = "sha256-2HcCibcP3/E3nu+PoNFChLFyCwAeAdp6I8mN95747Sg=";

     

       11
       11
       +
           sha256 = "sha256-A6EfP7l95eg9uL6NDqiPSzQ59JmTdE96UqunHETns9M=";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
       -
         vendorHash = "sha256-t2xiw1Z0BIT7pO4Z16XmsJE72RgL9Hobfy7LakpEYh4=";

     

       14
       14
       +
         vendorHash = "sha256-LJ288Z8xz/Xoy5I2OAk9v5hxRUkQcRTmNaQ31kHE8gQ=";

     

       15
       15
        
       

     

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

     

       17
       17

+2 -2

pkgs/tools/text/ugrep/default.nix

···

       11
       11
        
       

     

       12
       12
        
       stdenv.mkDerivation rec {

     

       13
       13
        
         pname = "ugrep";

     

       14
       14
       -
         version = "3.9.6";

     

       14
       14
       +
         version = "3.9.7";

     

       15
       15
        
       

     

       16
       16
        
         src = fetchFromGitHub {

     

       17
       17
        
           owner = "Genivia";

     

       18
       18
        
           repo = pname;

     

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

     

       20
       20
       -
           hash = "sha256-BzYlZl4NYjCXaM9ISGKSEP2xGFsE5GgX4zEIDniundo=";

     

       20
       20
       +
           hash = "sha256-y6P0EQfp2HFmhn2c7RwX8jVLUOfLT+LVhtz+OIoaVSo=";

     

       21
       21
        
         };

     

       22
       22
        
       

     

       23
       23
        
         buildInputs = [

+2 -2

pkgs/tools/wayland/swayimg/default.nix

···

       22
       22
        
       }:

     

       23
       23
        
       stdenv.mkDerivation rec {

     

       24
       24
        
         pname = "swayimg";

     

       25
       25
       -
         version = "1.9";

     

       25
       25
       +
         version = "1.10";

     

       26
       26
        
       

     

       27
       27
        
         src = fetchFromGitHub {

     

       28
       28
        
           owner = "artemsen";

     

       29
       29
        
           repo = pname;

     

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

     

       31
       31
       -
           sha256 = "sha256-864riSvWhWV4X84UeZ+xfQBOAQmwMrX6s90TXMGeruY=";

     

       31
       31
       +
           sha256 = "sha256-Iq7T00hvr9Mv50V/GKJBddjoeHdFa2DneVaXyxhMCE0=";

     

       32
       32
        
         };

     

       33
       33
        
       

     

       34
       34
        
         strictDeps = true;

+53 -19

pkgs/top-level/all-packages.nix

···

       2171
       2171
        
       

     

       2172
       2172
        
         pcsxr = callPackage ../applications/emulators/pcsxr { };

     

       2173
       2173
        
       

     

       2174
       2174
       -
         ppsspp = callPackage ../applications/emulators/ppsspp { };

     

       2174
       2174
       +
         ppsspp = libsForQt5.callPackage ../applications/emulators/ppsspp { };

     

       2175
       2175
        
       

     

       2176
       2176
        
         ppsspp-sdl = ppsspp;

     

       2177
       2177
        
       

     
···

       2181
       2181
        
         };

     

       2182
       2182
        
       

     

       2183
       2183
        
         ppsspp-qt = ppsspp.override {

     

       2184
       2184
       -
           inherit (libsForQt5) qtbase qtmultimedia wrapQtAppsHook;

     

       2184
       2184
       +
           enableQt = true;

     

       2185
       2185
        
           enableVulkan = false; # https://github.com/hrydgard/ppsspp/issues/11628

     

       2186
       2186
        
         };

     

       2187
       2187
        
       

     
···

       5406
       5406
        
       

     

       5407
       5407
        
         rex = callPackage ../tools/system/rex { };

     

       5408
       5408
        
       

     

       5409
       5409
       -
         river = callPackage ../applications/window-managers/river { };

     

       5409
       5409
       +
         river = callPackage ../applications/window-managers/river {

     

       5410
       5410
       +
           zig = zig_0_9;

     

       5411
       5411
       +
         };

     

       5410
       5412
        
       

     

       5411
       5411
       -
         rivercarro = callPackage ../applications/misc/rivercarro { };

     

       5413
       5413
       +
         rivercarro = callPackage ../applications/misc/rivercarro {

     

       5414
       5414
       +
           zig = zig_0_9;

     

       5415
       5415
       +
         };

     

       5412
       5416
        
       

     

       5413
       5417
        
         rmapi = callPackage ../applications/misc/remarkable/rmapi { };

     

       5414
       5418
        
       

     
···

       7254
       7258
        
       

     

       7255
       7259
        
         findutils = callPackage ../tools/misc/findutils { };

     

       7256
       7260
        
       

     

       7257
       7257
       -
         findup = callPackage ../tools/misc/findup { };

     

       7261
       7261
       +
         findup = callPackage ../tools/misc/findup {

     

       7262
       7262
       +
           zig = zig_0_9;

     

       7263
       7263
       +
         };

     

       7258
       7264
        
       

     

       7259
       7265
        
         bsd-finger = callPackage ../tools/networking/bsd-finger { };

     

       7260
       7266
        
         bsd-fingerd = bsd-finger.override({ buildClient = false; });

     
···

       7597
       7603
        
       

     

       7598
       7604
        
         gitkraken = callPackage ../applications/version-management/gitkraken { };

     

       7599
       7605
        
       

     

       7600
       7600
       -
         gitlab = callPackage ../applications/version-management/gitlab {

     

       7601
       7601
       -
           openssl = openssl_1_1;

     

       7602
       7602
       -
         };

     

       7606
       7606
       +
         gitlab = callPackage ../applications/version-management/gitlab { };

     

       7603
       7607
        
         gitlab-ee = callPackage ../applications/version-management/gitlab {

     

       7604
       7604
       -
           openssl = openssl_1_1;

     

       7605
       7608
        
           gitlabEnterprise = true;

     

       7606
       7609
        
         };

     

       7607
       7610
        
       

     
···

       9804
       9807
        
         mole = callPackage ../tools/networking/mole { };

     

       9805
       9808
        
       

     

       9806
       9809
        
         morgen = callPackage ../applications/office/morgen {

     

       9807
       9807
       -
           electron = electron_15;

     

       9810
       9810
       +
           electron = electron_22;

     

       9808
       9811
        
         };

     

       9809
       9812
        
       

     

       9810
       9813
        
         mosh = callPackage ../tools/networking/mosh { };

     
···

       12729
       12732
        
       

     

       12730
       12733
        
         oysttyer = callPackage ../applications/networking/instant-messengers/oysttyer { };

     

       12731
       12734
        
       

     

       12735
       12735
       +
         ttfb = callPackage ../development/tools/ttfb { };

     

       12736
       12736
       +
       

     

       12732
       12737
        
         twilight = callPackage ../tools/graphics/twilight {

     

       12733
       12738
        
           libX11 = xorg.libX11;

     

       12734
       12739
        
         };

     
···

       16529
       16534
        
           bluezSupport = true;

     

       16530
       16535
        
           x11Support = true;

     

       16531
       16536
        
         };

     

       16532
       16532
       -
         python311Full = python310.override {

     

       16537
       16537
       +
         python311Full = python311.override {

     

       16533
       16538
        
           self = python311Full;

     

       16534
       16539
        
           pythonAttr = "python311Full";

     

       16535
       16540
        
           bluezSupport = true;

     
···

       18814
       18819
        
       

     

       18815
       18820
        
         ytt = callPackage ../development/tools/ytt {};

     

       18816
       18821
        
       

     

       18817
       18817
       -
         zls = callPackage ../development/tools/zls { };

     

       18822
       18822
       +
         zls = callPackage ../development/tools/zls {

     

       18823
       18823
       +
           zig = zig_0_9;

     

       18824
       18824
       +
         };

     

       18818
       18825
        
       

     

       18819
       18826
        
         zydis = callPackage ../development/libraries/zydis { };

     

       18820
       18827
        
       

     
···

       21321
       21328
        
       

     

       21322
       21329
        
         libiconvReal = callPackage ../development/libraries/libiconv { };

     

       21323
       21330
        
       

     

       21331
       21331
       +
         iconv =

     

       21332
       21332
       +
           if lib.elem stdenv.hostPlatform.libc [ "glibc" "musl" ] then

     

       21333
       21333
       +
             lib.getBin stdenv.cc.libc

     

       21334
       21334
       +
           else if stdenv.hostPlatform.isDarwin then

     

       21335
       21335
       +
             lib.getBin darwin.libiconv

     

       21336
       21336
       +
           else

     

       21337
       21337
       +
             lib.getBin libiconvReal;

     

       21338
       21338
       +
       

     

       21324
       21339
        
         # On non-GNU systems we need GNU Gettext for libintl.

     

       21325
       21340
        
         libintl = if stdenv.hostPlatform.libc != "glibc" then gettext else null;

     

       21326
       21341
        
       

     
···

       23833
       23848
        
         libzra = callPackage ../development/libraries/libzra { };

     

       23834
       23849
        
       

     

       23835
       23850
        
         # requires a newer Apple SDK

     

       23836
       23836
       -
         zig = darwin.apple_sdk_11_0.callPackage ../development/compilers/zig {

     

       23851
       23851
       +
         zig_0_9 = darwin.apple_sdk_11_0.callPackage ../development/compilers/zig/0.9.1.nix {

     

       23837
       23852
        
           llvmPackages = llvmPackages_13;

     

       23838
       23853
        
         };

     

       23854
       23854
       +
         # requires a newer Apple SDK

     

       23855
       23855
       +
         zig_0_10 = darwin.apple_sdk_11_0.callPackage ../development/compilers/zig/0.10.nix {

     

       23856
       23856
       +
           llvmPackages = llvmPackages_15;

     

       23857
       23857
       +
         };

     

       23858
       23858
       +
         # Zig 0.10.1 is broken on Darwin, so use 0.9.1 on Darwin instead.

     

       23859
       23859
       +
         zig = if stdenv.isDarwin then zig_0_9 else zig_0_10;

     

       23839
       23860
        
       

     

       23840
       23861
        
         zimlib = callPackage ../development/libraries/zimlib { };

     

       23841
       23862
        
       

     
···

       25073
       25094
        
         prometheus-rtl_433-exporter = callPackage ../servers/monitoring/prometheus/rtl_433-exporter.nix { };

     

       25074
       25095
        
         prometheus-sachet = callPackage ../servers/monitoring/prometheus/sachet.nix { };

     

       25075
       25096
        
         prometheus-script-exporter = callPackage ../servers/monitoring/prometheus/script-exporter.nix { };

     

       25097
       25097
       +
         prometheus-shelly-exporter = callPackage ../servers/monitoring/prometheus/shelly-exporter.nix { };

     

       25076
       25098
        
         prometheus-smartctl-exporter = callPackage ../servers/monitoring/prometheus/smartctl-exporter { };

     

       25077
       25099
        
         prometheus-smokeping-prober = callPackage ../servers/monitoring/prometheus/smokeping-prober.nix { };

     

       25078
       25100
        
         prometheus-snmp-exporter = callPackage ../servers/monitoring/prometheus/snmp-exporter.nix { };

     
···

       27715
       27737
        
         roboto = callPackage ../data/fonts/roboto { };

     

       27716
       27738
        
       

     

       27717
       27739
        
         roboto-mono = callPackage ../data/fonts/roboto-mono { };

     

       27740
       27740
       +
       

     

       27741
       27741
       +
         roboto-serif = callPackage ../data/fonts/roboto-serif { };

     

       27718
       27742
        
       

     

       27719
       27743
        
         roboto-slab = callPackage ../data/fonts/roboto-slab { };

     

       27720
       27744
        
       

     
···

       28844
       28868
        
         dunst = callPackage ../applications/misc/dunst { };

     

       28845
       28869
        
       

     

       28846
       28870
        
         du-dust = callPackage ../tools/misc/dust {

     

       28847
       28847
       -
           inherit (darwin.apple_sdk.frameworks) AppKit;

     

       28871
       28871
       +
           inherit (darwin.apple_sdk_11_0.frameworks) AppKit;

     

       28848
       28872
        
         };

     

       28849
       28873
        
       

     

       28850
       28874
        
         dutree = callPackage ../tools/misc/dutree { };

     
···

       30187
       30211
        
       

     

       30188
       30212
        
         waybar = callPackage ../applications/misc/waybar {};

     

       30189
       30213
        
       

     

       30190
       30190
       -
         waylock = callPackage ../applications/misc/waylock {};

     

       30214
       30214
       +
         waylock = callPackage ../applications/misc/waylock {

     

       30215
       30215
       +
           zig = zig_0_9;

     

       30216
       30216
       +
         };

     

       30191
       30217
        
       

     

       30192
       30218
        
         wayshot = callPackage ../tools/misc/wayshot { };

     

       30193
       30219
        
       

     
···

       31104
       31130
        
       

     

       31105
       31131
        
         merkaartor = libsForQt5.callPackage ../applications/misc/merkaartor { };

     

       31106
       31132
        
       

     

       31107
       31107
       -
         mepo = callPackage ../applications/misc/mepo { };

     

       31133
       31133
       +
         mepo = callPackage ../applications/misc/mepo {

     

       31134
       31134
       +
           zig = zig_0_9;

     

       31135
       31135
       +
         };

     

       31108
       31136
        
       

     

       31109
       31137
        
         meshcentral = callPackage ../tools/admin/meshcentral { };

     

       31110
       31138
        
       

     
···

       31743
       31771
        
       

     

       31744
       31772
        
         netcoredbg = callPackage ../development/tools/misc/netcoredbg { };

     

       31745
       31773
        
       

     

       31746
       31746
       -
         ncdu = callPackage ../tools/misc/ncdu { };

     

       31774
       31774
       +
         ncdu = callPackage ../tools/misc/ncdu {

     

       31775
       31775
       +
           zig = zig_0_9;

     

       31776
       31776
       +
         };

     

       31747
       31777
        
         ncdu_1 = callPackage ../tools/misc/ncdu/1.nix { };

     

       31748
       31778
        
       

     

       31749
       31779
        
         ncdc = callPackage ../applications/networking/p2p/ncdc { };

     
···

       32058
       32088
        
         pianobooster = qt5.callPackage ../applications/audio/pianobooster { };

     

       32059
       32089
        
       

     

       32060
       32090
        
         pianoteq = callPackage ../applications/audio/pianoteq { };

     

       32091
       32091
       +
       

     

       32092
       32092
       +
         pianotrans = callPackage ../applications/audio/pianotrans { };

     

       32061
       32093
        
       

     

       32062
       32094
        
         picard = callPackage ../applications/audio/picard { };

     

       32063
       32095
        
       

     
···

       34768
       34800
        
           inherit (perlPackages) PathTiny;

     

       34769
       34801
        
         };

     

       34770
       34802
        
       

     

       34771
       34771
       -
         blackshades = callPackage ../games/blackshades { };

     

       34803
       34803
       +
         blackshades = callPackage ../games/blackshades {

     

       34804
       34804
       +
           zig = zig_0_9;

     

       34805
       34805
       +
         };

     

       34772
       34806
        
       

     

       34773
       34807
        
         blobby = callPackage ../games/blobby { };

     

       34774
       34808
        
       

     
···

       37911
       37945
        
       

     

       37912
       37946
        
         pgadmin4 = callPackage ../tools/admin/pgadmin { };

     

       37913
       37947
        
       

     

       37914
       37914
       -
         pgmodeler = libsForQt5.callPackage ../applications/misc/pgmodeler { };

     

       37948
       37948
       +
         pgmodeler = qt6Packages.callPackage ../applications/misc/pgmodeler { };

     

       37915
       37949
        
       

     

       37916
       37950
        
         physlock = callPackage ../misc/screensavers/physlock { };

     

       37917
       37951

+1 -1

pkgs/top-level/pkg-config/test-defaultPkgConfigPackages.nix

···

       42
       42
        
           else testers.hasPkgConfigModule { inherit moduleName; package = pkg; };

     

       43
       43
        
       

     

       44
       44
        
       in

     

       45
       45
       -
         allTests // { inherit tests-combined; }

     

       45
       45
       +
         lib.recurseIntoAttrs allTests // { inherit tests-combined; }

+8 -6

pkgs/top-level/python-packages.nix

···

       3079
       3079
        
       

     

       3080
       3080
        
         etebase = callPackage ../development/python-modules/etebase {

     

       3081
       3081
        
           inherit (pkgs.darwin.apple_sdk.frameworks) Security;

     

       3082
       3082
       -
           openssl = pkgs.openssl_1_1;

     

       3083
       3082
        
         };

     

       3084
       3083
        
       

     

       3085
       3084
        
         etebase-server = callPackage ../servers/etebase { };

     
···

       5584
       5583
        
       

     

       5585
       5584
        
         lzstring = callPackage ../development/python-modules/lzstring { };

     

       5586
       5585
        
       

     

       5587
       5587
       -
         m2crypto = callPackage ../development/python-modules/m2crypto {

     

       5588
       5588
       -
           # https://gitlab.com/m2crypto/m2crypto/-/issues/310

     

       5589
       5589
       -
           openssl = pkgs.openssl_1_1;

     

       5590
       5590
       -
         };

     

       5586
       5586
       +
         m2crypto = callPackage ../development/python-modules/m2crypto { };

     

       5591
       5587
        
       

     

       5592
       5588
        
         m2r = callPackage ../development/python-modules/m2r { };

     

       5593
       5589
        
       

     
···

       7069
       7065
        
       

     

       7070
       7066
        
         pi1wire = callPackage ../development/python-modules/pi1wire { };

     

       7071
       7067
        
       

     

       7068
       7068
       +
         piano-transcription-inference = callPackage ../development/python-modules/piano-transcription-inference { };

     

       7069
       7069
       +
       

     

       7072
       7070
        
         piccata = callPackage ../development/python-modules/piccata { };

     

       7073
       7071
        
       

     

       7074
       7072
        
         pick = callPackage ../development/python-modules/pick { };

     
···

       11263
       11261
        
       

     

       11264
       11262
        
         tensorflow-metadata = callPackage ../development/python-modules/tensorflow-metadata { };

     

       11265
       11263
        
       

     

       11266
       11266
       -
         tensorflow-probability = callPackage ../development/python-modules/tensorflow-probability { };

     

       11264
       11264
       +
         tensorflow-probability = callPackage ../development/python-modules/tensorflow-probability {

     

       11265
       11265
       +
           inherit (pkgs.darwin) cctools;

     

       11266
       11266
       +
         };

     

       11267
       11267
        
       

     

       11268
       11268
        
         tensorflow = self.tensorflow-build;

     

       11269
       11269
        
       

     
···

       11530
       11530
        
         torchmetrics = callPackage ../development/python-modules/torchmetrics { };

     

       11531
       11531
        
       

     

       11532
       11532
        
         torchinfo = callPackage ../development/python-modules/torchinfo { };

     

       11533
       11533
       +
       

     

       11534
       11534
       +
         torchlibrosa = callPackage ../development/python-modules/torchlibrosa { };

     

       11533
       11535
        
       

     

       11534
       11536
        
         torchvision = callPackage ../development/python-modules/torchvision { };

     

       11535
       11537