commit 51d40a0f08497d2a521a7b03486cf75d61759c19 · pyrox.dev/nixpkgs

+1 -1

maintainers/maintainer-list.nix

···

       13573
       13573
        
         };

     

       13574
       13574
        
         lgcl = {

     

       13575
       13575
        
           email = "dev@lgcl.de";

     

       13576
       13576
       -
           name = "Leon Vack";

     

       13576
       13576
       +
           name = "Leonie Marcy Vack";

     

       13577
       13577
        
           github = "LogicalOverflow";

     

       13578
       13578
        
           githubId = 5919957;

     

       13579
       13579
        
         };

+1 -1

nixos/modules/services/backup/znapzend.nix

···

       474
       474
        
               after = [ "zfs.target" ];

     

       475
       475
        
       

     

       476
       476
        
               path = with pkgs; [

     

       477
       477
       -
                 zfs

     

       477
       477
       +
                 config.boot.zfs.package

     

       478
       478
        
                 mbuffer

     

       479
       479
        
                 openssh

     

       480
       480
        
               ];

+1 -1

nixos/modules/services/cluster/k3s/default.nix

···

       458
       458
        
             type = with lib.types; either str (listOf str);

     

       459
       459
        
             default = [ ];

     

       460
       460
        
             example = [

     

       461
       461
       -
               "--no-deploy traefik"

     

       461
       461
       +
               "--disable traefik"

     

       462
       462
        
               "--cluster-cidr 10.24.0.0/16"

     

       463
       463
        
             ];

     

       464
       464
        
           };

+19 -32

nixos/modules/services/misc/bees.nix

···

       97
       97
        
             '';

     

       98
       98
        
           };

     

       99
       99
        
         };

     

       100
       100
       -
         config = {

     

       100
       100
       +
         config = lib.mkIf (cfg.filesystems != { }) {

     

       101
       101
       +
           systemd.packages = [ pkgs.bees ];

     

       101
       102
        
           systemd.services = lib.mapAttrs' (

     

       102
       103
        
             name: fs:

     

       103
       104
        
             lib.nameValuePair "beesd@${name}" {

     

       104
       104
       -
               description = "Block-level BTRFS deduplication for %i";

     

       105
       105
       -
               after = [ "sysinit.target" ];

     

       106
       106
       -
       

     

       107
       107
       -
               serviceConfig =

     

       108
       108
       -
                 let

     

       109
       109
       -
                   configOpts = [

     

       110
       110
       -
                     fs.spec

     

       111
       111
       -
                     "verbosity=${toString fs.verbosity}"

     

       112
       112
       -
                     "idxSizeMB=${toString fs.hashTableSizeMB}"

     

       113
       113
       -
                     "workDir=${fs.workDir}"

     

       105
       105
       +
               overrideStrategy = "asDropin";

     

       106
       106
       +
               serviceConfig = {

     

       107
       107
       +
                 ExecStart =

     

       108
       108
       +
                   let

     

       109
       109
       +
                     configOpts = [

     

       110
       110
       +
                       fs.spec

     

       111
       111
       +
                       "verbosity=${toString fs.verbosity}"

     

       112
       112
       +
                       "idxSizeMB=${toString fs.hashTableSizeMB}"

     

       113
       113
       +
                       "workDir=${fs.workDir}"

     

       114
       114
       +
                     ];

     

       115
       115
       +
                     configOptsStr = lib.escapeShellArgs configOpts;

     

       116
       116
       +
                   in

     

       117
       117
       +
                   [

     

       118
       118
       +
                     ""

     

       119
       119
       +
                     "${pkgs.bees}/bin/bees-service-wrapper run ${configOptsStr} -- --no-timestamps ${lib.escapeShellArgs fs.extraOptions}"

     

       114
       120
        
                   ];

     

       115
       115
       -
                   configOptsStr = lib.escapeShellArgs configOpts;

     

       116
       116
       -
                 in

     

       117
       117
       -
                 {

     

       118
       118
       -
                   # Values from https://github.com/Zygo/bees/blob/v0.6.5/scripts/beesd@.service.in

     

       119
       119
       -
                   ExecStart = "${pkgs.bees}/bin/bees-service-wrapper run ${configOptsStr} -- --no-timestamps ${lib.escapeShellArgs fs.extraOptions}";

     

       120
       120
       -
                   ExecStopPost = "${pkgs.bees}/bin/bees-service-wrapper cleanup ${configOptsStr}";

     

       121
       121
       -
                   CPUAccounting = true;

     

       122
       122
       -
                   CPUSchedulingPolicy = "batch";

     

       123
       123
       -
                   CPUWeight = 12;

     

       124
       124
       -
                   IOSchedulingClass = "idle";

     

       125
       125
       -
                   IOSchedulingPriority = 7;

     

       126
       126
       -
                   IOWeight = 10;

     

       127
       127
       -
                   KillMode = "control-group";

     

       128
       128
       -
                   KillSignal = "SIGTERM";

     

       129
       129
       -
                   MemoryAccounting = true;

     

       130
       130
       -
                   Nice = 19;

     

       131
       131
       -
                   Restart = "on-abnormal";

     

       132
       132
       -
                   StartupCPUWeight = 25;

     

       133
       133
       -
                   StartupIOWeight = 25;

     

       134
       134
       -
                   SyslogIdentifier = "beesd"; # would otherwise be "bees-service-wrapper"

     

       135
       135
       -
                 };

     

       121
       121
       +
                 SyslogIdentifier = "beesd"; # would otherwise be "bees-service-wrapper"

     

       122
       122
       +
               };

     

       136
       123
        
               unitConfig.RequiresMountsFor = lib.mkIf (lib.hasPrefix "/" fs.spec) fs.spec;

     

       137
       124
        
               wantedBy = [ "multi-user.target" ];

     

       138
       125
        
             }

+1 -1

nixos/modules/services/networking/dhcpcd.nix

···

       226
       226
        
               (IPv4 or IPv6) to be assigned. If set to "both", dhcpcd will wait for

     

       227
       227
        
               both an IPv4 and an IPv6 address before forking.

     

       228
       228
        
               The option "if-carrier-up" is equivalent to "any" if either ethernet

     

       229
       229
       -
               is plugged nor WiFi is powered, and to "background" otherwise.

     

       229
       229
       +
               is plugged or WiFi is powered, and to "background" otherwise.

     

       230
       230
        
             '';

     

       231
       231
        
           };

     

       232
       232

-1

nixos/modules/services/security/kanidm.nix

···

       908
       908
        
                 TemporaryFileSystem = "/:ro";

     

       909
       909
        
               }

     

       910
       910
        
             ];

     

       911
       911
       -
             environment.RUST_LOG = "info";

     

       912
       911
        
           };

     

       913
       912
        
       

     

       914
       913
        
           systemd.services.kanidm-unixd = mkIf cfg.enablePam {

+2 -2

nixos/tests/all-tests.nix

···

       800
       800
        
         mopidy = handleTest ./mopidy.nix { };

     

       801
       801
        
         morph-browser = runTest ./morph-browser.nix;

     

       802
       802
        
         morty = handleTest ./morty.nix { };

     

       803
       803
       -
         mosquitto = handleTest ./mosquitto.nix { };

     

       803
       803
       +
         mosquitto = runTest ./mosquitto.nix;

     

       804
       804
        
         moosefs = handleTest ./moosefs.nix { };

     

       805
       805
        
         movim = discoverTests (import ./web-apps/movim { inherit handleTestOn; });

     

       806
       806
        
         mpd = handleTest ./mpd.nix { };

     

       807
       807
       -
         mpv = handleTest ./mpv.nix { };

     

       807
       807
       +
         mpv = runTest ./mpv.nix;

     

       808
       808
        
         mtp = handleTest ./mtp.nix { };

     

       809
       809
        
         multipass = handleTest ./multipass.nix { };

     

       810
       810
        
         mumble = handleTest ./mumble.nix { };

+201 -203

nixos/tests/mosquitto.nix

···

       1
       1
       -
       import ./make-test-python.nix (

     

       2
       2
       -
         { pkgs, lib, ... }:

     

       1
       1
       +
       { pkgs, ... }:

     

       3
       2
        
       

     

       4
       4
       -
         let

     

       5
       5
       -
           port = 1888;

     

       6
       6
       -
           tlsPort = 1889;

     

       7
       7
       -
           anonPort = 1890;

     

       8
       8
       -
           password = "VERY_secret";

     

       9
       9
       -
           hashedPassword = "$7$101$/WJc4Mp+I+uYE9sR$o7z9rD1EYXHPwEP5GqQj6A7k4W1yVbePlb8TqNcuOLV9WNCiDgwHOB0JHC1WCtdkssqTBduBNUnUGd6kmZvDSw==";

     

       10
       10
       -
           topic = "test/foo";

     

       3
       3
       +
       let

     

       4
       4
       +
         port = 1888;

     

       5
       5
       +
         tlsPort = 1889;

     

       6
       6
       +
         anonPort = 1890;

     

       7
       7
       +
         password = "VERY_secret";

     

       8
       8
       +
         hashedPassword = "$7$101$/WJc4Mp+I+uYE9sR$o7z9rD1EYXHPwEP5GqQj6A7k4W1yVbePlb8TqNcuOLV9WNCiDgwHOB0JHC1WCtdkssqTBduBNUnUGd6kmZvDSw==";

     

       9
       9
       +
         topic = "test/foo";

     

       11
       10
        
       

     

       12
       12
       -
           snakeOil =

     

       13
       13
       -
             pkgs.runCommand "snakeoil-certs"

     

       14
       14
       -
               {

     

       15
       15
       -
                 buildInputs = [ pkgs.gnutls.bin ];

     

       16
       16
       -
                 caTemplate = pkgs.writeText "snakeoil-ca.template" ''

     

       17
       17
       -
                   cn = server

     

       18
       18
       -
                   expiration_days = -1

     

       19
       19
       -
                   cert_signing_key

     

       20
       20
       -
                   ca

     

       21
       21
       -
                 '';

     

       22
       22
       -
                 certTemplate = pkgs.writeText "snakeoil-cert.template" ''

     

       23
       23
       -
                   cn = server

     

       24
       24
       -
                   expiration_days = -1

     

       25
       25
       -
                   tls_www_server

     

       26
       26
       -
                   encryption_key

     

       27
       27
       -
                   signing_key

     

       28
       28
       -
                 '';

     

       29
       29
       -
                 userCertTemplate = pkgs.writeText "snakeoil-user-cert.template" ''

     

       30
       30
       -
                   organization = snakeoil

     

       31
       31
       -
                   cn = client1

     

       32
       32
       -
                   expiration_days = -1

     

       33
       33
       -
                   tls_www_client

     

       34
       34
       -
                   encryption_key

     

       35
       35
       -
                   signing_key

     

       36
       36
       -
                 '';

     

       37
       37
       -
               }

     

       38
       38
       -
               ''

     

       39
       39
       -
                 mkdir "$out"

     

       40
       40
       -
       

     

       41
       41
       -
                 certtool -p --bits 2048 --outfile "$out/ca.key"

     

       42
       42
       -
                 certtool -s --template "$caTemplate" --load-privkey "$out/ca.key" \

     

       43
       43
       -
                             --outfile "$out/ca.crt"

     

       44
       44
       -
                 certtool -p --bits 2048 --outfile "$out/server.key"

     

       45
       45
       -
                 certtool -c --template "$certTemplate" \

     

       46
       46
       -
                             --load-ca-privkey "$out/ca.key" \

     

       47
       47
       -
                             --load-ca-certificate "$out/ca.crt" \

     

       48
       48
       -
                             --load-privkey "$out/server.key" \

     

       49
       49
       -
                             --outfile "$out/server.crt"

     

       50
       50
       -
       

     

       51
       51
       -
                 certtool -p --bits 2048 --outfile "$out/client1.key"

     

       52
       52
       -
                 certtool -c --template "$userCertTemplate" \

     

       53
       53
       -
                             --load-privkey "$out/client1.key" \

     

       54
       54
       -
                             --load-ca-privkey "$out/ca.key" \

     

       55
       55
       -
                             --load-ca-certificate "$out/ca.crt" \

     

       56
       56
       -
                             --outfile "$out/client1.crt"

     

       11
       11
       +
         snakeOil =

     

       12
       12
       +
           pkgs.runCommand "snakeoil-certs"

     

       13
       13
       +
             {

     

       14
       14
       +
               buildInputs = [ pkgs.gnutls.bin ];

     

       15
       15
       +
               caTemplate = pkgs.writeText "snakeoil-ca.template" ''

     

       16
       16
       +
                 cn = server

     

       17
       17
       +
                 expiration_days = -1

     

       18
       18
       +
                 cert_signing_key

     

       19
       19
       +
                 ca

     

       20
       20
       +
               '';

     

       21
       21
       +
               certTemplate = pkgs.writeText "snakeoil-cert.template" ''

     

       22
       22
       +
                 cn = server

     

       23
       23
       +
                 expiration_days = -1

     

       24
       24
       +
                 tls_www_server

     

       25
       25
       +
                 encryption_key

     

       26
       26
       +
                 signing_key

     

       27
       27
       +
               '';

     

       28
       28
       +
               userCertTemplate = pkgs.writeText "snakeoil-user-cert.template" ''

     

       29
       29
       +
                 organization = snakeoil

     

       30
       30
       +
                 cn = client1

     

       31
       31
       +
                 expiration_days = -1

     

       32
       32
       +
                 tls_www_client

     

       33
       33
       +
                 encryption_key

     

       34
       34
       +
                 signing_key

     

       57
       35
        
               '';

     

       36
       36
       +
             }

     

       37
       37
       +
             ''

     

       38
       38
       +
               mkdir "$out"

     

       58
       39
        
       

     

       59
       59
       -
         in

     

       60
       60
       -
         {

     

       61
       61
       -
           name = "mosquitto";

     

       62
       62
       -
           meta = with pkgs.lib; {

     

       63
       63
       -
             maintainers = with maintainers; [ peterhoeg ];

     

       64
       64
       -
           };

     

       40
       40
       +
               certtool -p --bits 2048 --outfile "$out/ca.key"

     

       41
       41
       +
               certtool -s --template "$caTemplate" --load-privkey "$out/ca.key" \

     

       42
       42
       +
                           --outfile "$out/ca.crt"

     

       43
       43
       +
               certtool -p --bits 2048 --outfile "$out/server.key"

     

       44
       44
       +
               certtool -c --template "$certTemplate" \

     

       45
       45
       +
                           --load-ca-privkey "$out/ca.key" \

     

       46
       46
       +
                           --load-ca-certificate "$out/ca.crt" \

     

       47
       47
       +
                           --load-privkey "$out/server.key" \

     

       48
       48
       +
                           --outfile "$out/server.crt"

     

       65
       49
        
       

     

       66
       66
       -
           nodes =

     

       67
       67
       -
             let

     

       68
       68
       -
               client =

     

       69
       69
       -
                 { pkgs, ... }:

     

       70
       70
       -
                 {

     

       71
       71
       -
                   environment.systemPackages = with pkgs; [ mosquitto ];

     

       72
       72
       -
                 };

     

       73
       73
       -
             in

     

       74
       74
       -
             {

     

       75
       75
       -
               server =

     

       76
       76
       -
                 { pkgs, ... }:

     

       77
       77
       -
                 {

     

       78
       78
       -
                   networking.firewall.allowedTCPPorts = [

     

       79
       79
       -
                     port

     

       80
       80
       -
                     tlsPort

     

       81
       81
       -
                     anonPort

     

       82
       82
       -
                   ];

     

       83
       83
       -
                   networking.useNetworkd = true;

     

       84
       84
       -
                   services.mosquitto = {

     

       85
       85
       -
                     enable = true;

     

       86
       86
       -
                     settings = {

     

       87
       87
       -
                       sys_interval = 1;

     

       88
       88
       -
                     };

     

       89
       89
       -
                     listeners = [

     

       90
       90
       -
                       {

     

       91
       91
       -
                         inherit port;

     

       92
       92
       -
                         users = {

     

       93
       93
       -
                           password_store = {

     

       94
       94
       -
                             inherit password;

     

       95
       95
       -
                           };

     

       96
       96
       -
                           password_file = {

     

       97
       97
       -
                             passwordFile = pkgs.writeText "mqtt-password" password;

     

       98
       98
       -
                           };

     

       99
       99
       -
                           hashed_store = {

     

       100
       100
       -
                             inherit hashedPassword;

     

       101
       101
       -
                           };

     

       102
       102
       -
                           hashed_file = {

     

       103
       103
       -
                             hashedPasswordFile = pkgs.writeText "mqtt-hashed-password" hashedPassword;

     

       104
       104
       -
                           };

     

       50
       50
       +
               certtool -p --bits 2048 --outfile "$out/client1.key"

     

       51
       51
       +
               certtool -c --template "$userCertTemplate" \

     

       52
       52
       +
                           --load-privkey "$out/client1.key" \

     

       53
       53
       +
                           --load-ca-privkey "$out/ca.key" \

     

       54
       54
       +
                           --load-ca-certificate "$out/ca.crt" \

     

       55
       55
       +
                           --outfile "$out/client1.crt"

     

       56
       56
       +
             '';

     

       57
       57
       +
       

     

       58
       58
       +
       in

     

       59
       59
       +
       {

     

       60
       60
       +
         name = "mosquitto";

     

       61
       61
       +
         meta = with pkgs.lib; {

     

       62
       62
       +
           maintainers = with maintainers; [ peterhoeg ];

     

       63
       63
       +
         };

     

       105
       64
        
       

     

       106
       106
       -
                           reader = {

     

       107
       107
       -
                             inherit password;

     

       108
       108
       -
                             acl = [

     

       109
       109
       -
                               "read ${topic}"

     

       110
       110
       -
                               "read $SYS/#" # so we always have something to read

     

       111
       111
       -
                             ];

     

       112
       112
       -
                           };

     

       113
       113
       -
                           writer = {

     

       114
       114
       -
                             inherit password;

     

       115
       115
       -
                             acl = [ "write ${topic}" ];

     

       116
       116
       -
                           };

     

       65
       65
       +
         nodes =

     

       66
       66
       +
           let

     

       67
       67
       +
             client =

     

       68
       68
       +
               { pkgs, ... }:

     

       69
       69
       +
               {

     

       70
       70
       +
                 environment.systemPackages = with pkgs; [ mosquitto ];

     

       71
       71
       +
               };

     

       72
       72
       +
           in

     

       73
       73
       +
           {

     

       74
       74
       +
             server =

     

       75
       75
       +
               { pkgs, ... }:

     

       76
       76
       +
               {

     

       77
       77
       +
                 networking.firewall.allowedTCPPorts = [

     

       78
       78
       +
                   port

     

       79
       79
       +
                   tlsPort

     

       80
       80
       +
                   anonPort

     

       81
       81
       +
                 ];

     

       82
       82
       +
                 networking.useNetworkd = true;

     

       83
       83
       +
                 services.mosquitto = {

     

       84
       84
       +
                   enable = true;

     

       85
       85
       +
                   settings = {

     

       86
       86
       +
                     sys_interval = 1;

     

       87
       87
       +
                   };

     

       88
       88
       +
                   listeners = [

     

       89
       89
       +
                     {

     

       90
       90
       +
                       inherit port;

     

       91
       91
       +
                       users = {

     

       92
       92
       +
                         password_store = {

     

       93
       93
       +
                           inherit password;

     

       117
       94
        
                         };

     

       118
       118
       -
                       }

     

       119
       119
       -
                       {

     

       120
       120
       -
                         port = tlsPort;

     

       121
       121
       -
                         users.client1 = {

     

       122
       122
       -
                           acl = [ "read $SYS/#" ];

     

       95
       95
       +
                         password_file = {

     

       96
       96
       +
                           passwordFile = pkgs.writeText "mqtt-password" password;

     

       123
       97
        
                         };

     

       124
       124
       -
                         settings = {

     

       125
       125
       -
                           cafile = "${snakeOil}/ca.crt";

     

       126
       126
       -
                           certfile = "${snakeOil}/server.crt";

     

       127
       127
       -
                           keyfile = "${snakeOil}/server.key";

     

       128
       128
       -
                           require_certificate = true;

     

       129
       129
       -
                           use_identity_as_username = true;

     

       98
       98
       +
                         hashed_store = {

     

       99
       99
       +
                           inherit hashedPassword;

     

       100
       100
       +
                         };

     

       101
       101
       +
                         hashed_file = {

     

       102
       102
       +
                           hashedPasswordFile = pkgs.writeText "mqtt-hashed-password" hashedPassword;

     

       130
       103
        
                         };

     

       131
       131
       -
                       }

     

       132
       132
       -
                       {

     

       133
       133
       -
                         port = anonPort;

     

       134
       134
       -
                         omitPasswordAuth = true;

     

       135
       135
       -
                         settings.allow_anonymous = true;

     

       136
       136
       -
                         acl = [ "pattern read #" ];

     

       137
       137
       -
                         users = {

     

       138
       138
       -
                           anonWriter = {

     

       139
       139
       -
                             password = "<ignored>" + password;

     

       140
       140
       -
                             acl = [ "write ${topic}" ];

     

       141
       141
       -
                           };

     

       104
       104
       +
       

     

       105
       105
       +
                         reader = {

     

       106
       106
       +
                           inherit password;

     

       107
       107
       +
                           acl = [

     

       108
       108
       +
                             "read ${topic}"

     

       109
       109
       +
                             "read $SYS/#" # so we always have something to read

     

       110
       110
       +
                           ];

     

       111
       111
       +
                         };

     

       112
       112
       +
                         writer = {

     

       113
       113
       +
                           inherit password;

     

       114
       114
       +
                           acl = [ "write ${topic}" ];

     

       115
       115
       +
                         };

     

       116
       116
       +
                       };

     

       117
       117
       +
                     }

     

       118
       118
       +
                     {

     

       119
       119
       +
                       port = tlsPort;

     

       120
       120
       +
                       users.client1 = {

     

       121
       121
       +
                         acl = [ "read $SYS/#" ];

     

       122
       122
       +
                       };

     

       123
       123
       +
                       settings = {

     

       124
       124
       +
                         cafile = "${snakeOil}/ca.crt";

     

       125
       125
       +
                         certfile = "${snakeOil}/server.crt";

     

       126
       126
       +
                         keyfile = "${snakeOil}/server.key";

     

       127
       127
       +
                         require_certificate = true;

     

       128
       128
       +
                         use_identity_as_username = true;

     

       129
       129
       +
                       };

     

       130
       130
       +
                     }

     

       131
       131
       +
                     {

     

       132
       132
       +
                       port = anonPort;

     

       133
       133
       +
                       omitPasswordAuth = true;

     

       134
       134
       +
                       settings.allow_anonymous = true;

     

       135
       135
       +
                       acl = [ "pattern read #" ];

     

       136
       136
       +
                       users = {

     

       137
       137
       +
                         anonWriter = {

     

       138
       138
       +
                           password = "<ignored>" + password;

     

       139
       139
       +
                           acl = [ "write ${topic}" ];

     

       142
       140
        
                         };

     

       143
       143
       -
                       }

     

       144
       144
       -
                     ];

     

       145
       145
       -
                   };

     

       141
       141
       +
                       };

     

       142
       142
       +
                     }

     

       143
       143
       +
                   ];

     

       146
       144
        
                 };

     

       145
       145
       +
               };

     

       147
       146
        
       

     

       148
       148
       -
               client1 = client;

     

       149
       149
       -
               client2 = client;

     

       150
       150
       -
             };

     

       147
       147
       +
             client1 = client;

     

       148
       148
       +
             client2 = client;

     

       149
       149
       +
           };

     

       151
       150
        
       

     

       152
       152
       -
           testScript = ''

     

       153
       153
       -
             def mosquitto_cmd(binary, user, topic, port):

     

       154
       154
       -
                 return (

     

       155
       155
       -
                     "mosquitto_{} "

     

       156
       156
       -
                     "-V mqttv311 "

     

       157
       157
       -
                     "-h server "

     

       158
       158
       -
                     "-p {} "

     

       159
       159
       -
                     "-u {} "

     

       160
       160
       -
                     "-P '${password}' "

     

       161
       161
       -
                     "-t '{}'"

     

       162
       162
       -
                 ).format(binary, port, user, topic)

     

       151
       151
       +
         testScript = ''

     

       152
       152
       +
           def mosquitto_cmd(binary, user, topic, port):

     

       153
       153
       +
               return (

     

       154
       154
       +
                   "mosquitto_{} "

     

       155
       155
       +
                   "-V mqttv311 "

     

       156
       156
       +
                   "-h server "

     

       157
       157
       +
                   "-p {} "

     

       158
       158
       +
                   "-u {} "

     

       159
       159
       +
                   "-P '${password}' "

     

       160
       160
       +
                   "-t '{}'"

     

       161
       161
       +
               ).format(binary, port, user, topic)

     

       163
       162
        
       

     

       164
       163
        
       

     

       165
       165
       -
             def publish(args, user, topic="${topic}", port=${toString port}):

     

       166
       166
       -
                 return "{} {}".format(mosquitto_cmd("pub", user, topic, port), args)

     

       164
       164
       +
           def publish(args, user, topic="${topic}", port=${toString port}):

     

       165
       165
       +
               return "{} {}".format(mosquitto_cmd("pub", user, topic, port), args)

     

       167
       166
        
       

     

       168
       168
       -
             def subscribe(args, user, topic="${topic}", port=${toString port}):

     

       169
       169
       -
                 return "{} -W 5 -C 1 {}".format(mosquitto_cmd("sub", user, topic, port), args)

     

       167
       167
       +
           def subscribe(args, user, topic="${topic}", port=${toString port}):

     

       168
       168
       +
               return "{} -W 5 -C 1 {}".format(mosquitto_cmd("sub", user, topic, port), args)

     

       170
       169
        
       

     

       171
       171
       -
             def parallel(*fns):

     

       172
       172
       -
                 from threading import Thread

     

       173
       173
       -
                 threads = [ Thread(target=fn) for fn in fns ]

     

       174
       174
       -
                 for t in threads: t.start()

     

       175
       175
       -
                 for t in threads: t.join()

     

       170
       170
       +
           def parallel(*fns):

     

       171
       171
       +
               from threading import Thread

     

       172
       172
       +
               threads = [ Thread(target=fn) for fn in fns ]

     

       173
       173
       +
               for t in threads: t.start()

     

       174
       174
       +
               for t in threads: t.join()

     

       176
       175
        
       

     

       177
       177
       -
             def wait_uuid(uuid):

     

       178
       178
       -
                 server.wait_for_console_text(uuid)

     

       179
       179
       -
                 return None

     

       176
       176
       +
           def wait_uuid(uuid):

     

       177
       177
       +
               server.wait_for_console_text(uuid)

     

       178
       178
       +
               return None

     

       180
       179
        
       

     

       181
       180
        
       

     

       182
       182
       -
             start_all()

     

       183
       183
       -
             server.wait_for_unit("mosquitto.service")

     

       181
       181
       +
           start_all()

     

       182
       182
       +
           server.wait_for_unit("mosquitto.service")

     

       184
       183
        
       

     

       185
       185
       -
             with subtest("check passwords"):

     

       186
       186
       -
                 client1.succeed(publish("-m test", "password_store"))

     

       187
       187
       -
                 client1.succeed(publish("-m test", "password_file"))

     

       188
       188
       -
                 client1.succeed(publish("-m test", "hashed_store"))

     

       189
       189
       -
                 client1.succeed(publish("-m test", "hashed_file"))

     

       184
       184
       +
           with subtest("check passwords"):

     

       185
       185
       +
               client1.succeed(publish("-m test", "password_store"))

     

       186
       186
       +
               client1.succeed(publish("-m test", "password_file"))

     

       187
       187
       +
               client1.succeed(publish("-m test", "hashed_store"))

     

       188
       188
       +
               client1.succeed(publish("-m test", "hashed_file"))

     

       190
       189
        
       

     

       191
       191
       -
             with subtest("check acl"):

     

       192
       192
       -
                 client1.succeed(subscribe("", "reader", topic="$SYS/#"))

     

       193
       193
       -
                 client1.fail(subscribe("", "writer", topic="$SYS/#"))

     

       190
       190
       +
           with subtest("check acl"):

     

       191
       191
       +
               client1.succeed(subscribe("", "reader", topic="$SYS/#"))

     

       192
       192
       +
               client1.fail(subscribe("", "writer", topic="$SYS/#"))

     

       194
       193
        
       

     

       195
       195
       -
                 parallel(

     

       196
       196
       -
                     lambda: client1.succeed(subscribe("-i 3688cdd7-aa07-42a4-be22-cb9352917e40", "reader")),

     

       197
       197
       -
                     lambda: [

     

       198
       198
       -
                         wait_uuid("3688cdd7-aa07-42a4-be22-cb9352917e40"),

     

       199
       199
       -
                         client2.succeed(publish("-m test", "writer"))

     

       200
       200
       -
                     ])

     

       194
       194
       +
               parallel(

     

       195
       195
       +
                   lambda: client1.succeed(subscribe("-i 3688cdd7-aa07-42a4-be22-cb9352917e40", "reader")),

     

       196
       196
       +
                   lambda: [

     

       197
       197
       +
                       wait_uuid("3688cdd7-aa07-42a4-be22-cb9352917e40"),

     

       198
       198
       +
                       client2.succeed(publish("-m test", "writer"))

     

       199
       199
       +
                   ])

     

       201
       200
        
       

     

       202
       202
       -
                 parallel(

     

       203
       203
       -
                     lambda: client1.fail(subscribe("-i 24ff16a2-ae33-4a51-9098-1b417153c712", "reader")),

     

       204
       204
       -
                     lambda: [

     

       205
       205
       -
                         wait_uuid("24ff16a2-ae33-4a51-9098-1b417153c712"),

     

       206
       206
       -
                         client2.succeed(publish("-m test", "reader"))

     

       207
       207
       -
                     ])

     

       201
       201
       +
               parallel(

     

       202
       202
       +
                   lambda: client1.fail(subscribe("-i 24ff16a2-ae33-4a51-9098-1b417153c712", "reader")),

     

       203
       203
       +
                   lambda: [

     

       204
       204
       +
                       wait_uuid("24ff16a2-ae33-4a51-9098-1b417153c712"),

     

       205
       205
       +
                       client2.succeed(publish("-m test", "reader"))

     

       206
       206
       +
                   ])

     

       208
       207
        
       

     

       209
       209
       -
             with subtest("check tls"):

     

       210
       210
       -
                 client1.succeed(

     

       211
       211
       -
                     subscribe(

     

       212
       212
       -
                         "--cafile ${snakeOil}/ca.crt "

     

       213
       213
       -
                         "--cert ${snakeOil}/client1.crt "

     

       214
       214
       -
                         "--key ${snakeOil}/client1.key",

     

       215
       215
       -
                         topic="$SYS/#",

     

       216
       216
       -
                         port=${toString tlsPort},

     

       217
       217
       -
                         user="no_such_user"))

     

       208
       208
       +
           with subtest("check tls"):

     

       209
       209
       +
               client1.succeed(

     

       210
       210
       +
                   subscribe(

     

       211
       211
       +
                       "--cafile ${snakeOil}/ca.crt "

     

       212
       212
       +
                       "--cert ${snakeOil}/client1.crt "

     

       213
       213
       +
                       "--key ${snakeOil}/client1.key",

     

       214
       214
       +
                       topic="$SYS/#",

     

       215
       215
       +
                       port=${toString tlsPort},

     

       216
       216
       +
                       user="no_such_user"))

     

       218
       217
        
       

     

       219
       219
       -
             with subtest("check omitPasswordAuth"):

     

       220
       220
       -
                 parallel(

     

       221
       221
       -
                     lambda: client1.succeed(subscribe("-i fd56032c-d9cb-4813-a3b4-6be0e04c8fc3",

     

       222
       222
       -
                         "anonReader", port=${toString anonPort})),

     

       223
       223
       -
                     lambda: [

     

       224
       224
       -
                         wait_uuid("fd56032c-d9cb-4813-a3b4-6be0e04c8fc3"),

     

       225
       225
       -
                         client2.succeed(publish("-m test", "anonWriter", port=${toString anonPort}))

     

       226
       226
       -
                     ])

     

       227
       227
       -
           '';

     

       228
       228
       -
         }

     

       229
       229
       -
       )

     

       218
       218
       +
           with subtest("check omitPasswordAuth"):

     

       219
       219
       +
               parallel(

     

       220
       220
       +
                   lambda: client1.succeed(subscribe("-i fd56032c-d9cb-4813-a3b4-6be0e04c8fc3",

     

       221
       221
       +
                       "anonReader", port=${toString anonPort})),

     

       222
       222
       +
                   lambda: [

     

       223
       223
       +
                       wait_uuid("fd56032c-d9cb-4813-a3b4-6be0e04c8fc3"),

     

       224
       224
       +
                       client2.succeed(publish("-m test", "anonWriter", port=${toString anonPort}))

     

       225
       225
       +
                   ])

     

       226
       226
       +
         '';

     

       227
       227
       +
       }

+23 -25

nixos/tests/mpv.nix

···

       1
       1
       -
       import ./make-test-python.nix (

     

       2
       2
       -
         { lib, ... }:

     

       1
       1
       +
       { lib, ... }:

     

       3
       2
        
       

     

       4
       4
       -
         let

     

       5
       5
       -
           port = toString 4321;

     

       6
       6
       -
         in

     

       7
       7
       -
         {

     

       8
       8
       -
           name = "mpv";

     

       9
       9
       -
           meta.maintainers = with lib.maintainers; [ zopieux ];

     

       3
       3
       +
       let

     

       4
       4
       +
         port = toString 4321;

     

       5
       5
       +
       in

     

       6
       6
       +
       {

     

       7
       7
       +
         name = "mpv";

     

       8
       8
       +
         meta.maintainers = with lib.maintainers; [ zopieux ];

     

       10
       9
        
       

     

       11
       11
       -
           nodes.machine =

     

       12
       12
       -
             { pkgs, ... }:

     

       13
       13
       -
             {

     

       14
       14
       -
               environment.systemPackages = [

     

       15
       15
       -
                 pkgs.curl

     

       16
       16
       -
                 (pkgs.mpv.override {

     

       17
       17
       -
                   scripts = [ pkgs.mpvScripts.simple-mpv-webui ];

     

       18
       18
       -
                 })

     

       19
       19
       -
               ];

     

       20
       20
       -
             };

     

       10
       10
       +
         nodes.machine =

     

       11
       11
       +
           { pkgs, ... }:

     

       12
       12
       +
           {

     

       13
       13
       +
             environment.systemPackages = [

     

       14
       14
       +
               pkgs.curl

     

       15
       15
       +
               (pkgs.mpv.override {

     

       16
       16
       +
                 scripts = [ pkgs.mpvScripts.simple-mpv-webui ];

     

       17
       17
       +
               })

     

       18
       18
       +
             ];

     

       19
       19
       +
           };

     

       21
       20
        
       

     

       22
       22
       -
           testScript = ''

     

       23
       23
       -
             machine.execute("set -m; mpv --script-opts=webui-port=${port} --idle=yes >&2 &")

     

       24
       24
       -
             machine.wait_for_open_port(${port})

     

       25
       25
       -
             assert "<title>simple-mpv-webui" in machine.succeed("curl -s localhost:${port}")

     

       26
       26
       -
           '';

     

       27
       27
       -
         }

     

       28
       28
       -
       )

     

       21
       21
       +
         testScript = ''

     

       22
       22
       +
           machine.execute("set -m; mpv --script-opts=webui-port=${port} --idle=yes >&2 &")

     

       23
       23
       +
           machine.wait_for_open_port(${port})

     

       24
       24
       +
           assert "<title>simple-mpv-webui" in machine.succeed("curl -s localhost:${port}")

     

       25
       25
       +
         '';

     

       26
       26
       +
       }

+2 -2

pkgs/applications/misc/ArchiSteamFarm/default.nix

···

       12
       12
        
       buildDotnetModule rec {

     

       13
       13
        
         pname = "ArchiSteamFarm";

     

       14
       14
        
         # nixpkgs-update: no auto update

     

       15
       15
       -
         version = "6.1.3.3";

     

       15
       15
       +
         version = "6.1.4.3";

     

       16
       16
        
       

     

       17
       17
        
         src = fetchFromGitHub {

     

       18
       18
        
           owner = "JustArchiNET";

     

       19
       19
        
           repo = "ArchiSteamFarm";

     

       20
       20
        
           rev = version;

     

       21
       21
       -
           hash = "sha256-kwCmOPgO1YR2VgAwvu/c9iTWHWFZGsZCkbAsWoeLTV0=";

     

       21
       21
       +
           hash = "sha256-PTO4x5YKqs4wWonW3N/sMAVlbWJp+eVjLL98G9bNZ4c=";

     

       22
       22
        
         };

     

       23
       23
        
       

     

       24
       24
        
         dotnet-runtime = dotnetCorePackages.aspnetcore_9_0;

+65 -70

pkgs/applications/misc/ArchiSteamFarm/deps.json

···

       5
       5
        
           "hash": "sha256-l8+Var9o773VL6Ybih3boaFf9sYjS7eqtLGd8DCIPsk="

     

       6
       6
        
         },

     

       7
       7
        
         {

     

       8
       8
       -
           "pname": "AngleSharp.XPath",

     

       9
       9
       -
           "version": "2.0.5",

     

       10
       10
       -
           "hash": "sha256-V2ehfOdVI16QdsQ+FrxZZGnUvbEbt3Ldr9LPF/dF69A="

     

       11
       11
       -
         },

     

       12
       12
       -
         {

     

       13
       8
        
           "pname": "CryptSharpStandard",

     

       14
       9
        
           "version": "1.0.0",

     

       15
       10
        
           "hash": "sha256-58ukrKgmk9w5ZyuQU67KS3du4zvkfJ1MskKRL9L6M1o="

     
···

       291
       286
        
         },

     

       292
       287
        
         {

     

       293
       288
        
           "pname": "Microsoft.AspNetCore.OpenApi",

     

       294
       294
       -
           "version": "9.0.2",

     

       295
       295
       -
           "hash": "sha256-zqsI0lEDrP8l2QaDxRxb4SC4mwxVfYGFYp/wURXRzKs="

     

       289
       289
       +
           "version": "9.0.3",

     

       290
       290
       +
           "hash": "sha256-URV7tlaHv1JPpqeJXQMYRoIZYU7lFGJPyTKbl2p3gqI="

     

       296
       291
        
         },

     

       297
       292
        
         {

     

       298
       293
        
           "pname": "Microsoft.Bcl.AsyncInterfaces",

     
···

       301
       296
        
         },

     

       302
       297
        
         {

     

       303
       298
        
           "pname": "Microsoft.CodeAnalysis.ResxSourceGenerator",

     

       304
       304
       -
           "version": "3.11.0-beta1.24629.2",

     

       305
       305
       -
           "hash": "sha256-f4UuX2syNwccB3TbN73jw4JBXxgiyeE6PzLylcdyeWg="

     

       299
       299
       +
           "version": "3.11.0-beta1.25076.3",

     

       300
       300
       +
           "hash": "sha256-JCyHBJ7BhQFem8vp96ewwFvWaZccOBg1viAHxZwzORg="

     

       306
       301
        
         },

     

       307
       302
        
         {

     

       308
       303
        
           "pname": "Microsoft.CodeCoverage",

     
···

       446
       441
        
         },

     

       447
       442
        
         {

     

       448
       443
        
           "pname": "Microsoft.IdentityModel.Abstractions",

     

       449
       449
       -
           "version": "8.6.0",

     

       450
       450
       -
           "hash": "sha256-0mXOkDKvUikcyCMUcmA7PWl4RlAwwUciKSqTTgLDa3o="

     

       444
       444
       +
           "version": "8.7.0",

     

       445
       445
       +
           "hash": "sha256-LqEtksyd06m12yasVQK/9j6Y/giTDqfMJrdUUDxW0WY="

     

       451
       446
        
         },

     

       452
       447
        
         {

     

       453
       448
        
           "pname": "Microsoft.IdentityModel.JsonWebTokens",

     

       454
       454
       -
           "version": "8.6.0",

     

       455
       455
       -
           "hash": "sha256-Wey0xjL0n6NCi4HiVFGcDS6+ONPp+ogzb5ZTF7sFt3k="

     

       449
       449
       +
           "version": "8.7.0",

     

       450
       450
       +
           "hash": "sha256-P9oPGIyaZrRd1EqhgvuSF5Bt/7fm/dS3nC3HXo4C720="

     

       456
       451
        
         },

     

       457
       452
        
         {

     

       458
       453
        
           "pname": "Microsoft.IdentityModel.Logging",

     

       459
       459
       -
           "version": "8.6.0",

     

       460
       460
       -
           "hash": "sha256-4M4EUJDMDgmqdBxlbptnrLNWOLbmzatypDpl30CBUlk="

     

       454
       454
       +
           "version": "8.7.0",

     

       455
       455
       +
           "hash": "sha256-yXyiQR87kb630Qwu+D0GifWxPj74VN7wtzOincrSdIg="

     

       461
       456
        
         },

     

       462
       457
        
         {

     

       463
       458
        
           "pname": "Microsoft.IdentityModel.Tokens",

     

       464
       464
       -
           "version": "8.6.0",

     

       465
       465
       -
           "hash": "sha256-gyZpy8h9I09fr7icHaIXaxRTzhstHrrrq2wkd/5vz78="

     

       459
       459
       +
           "version": "8.7.0",

     

       460
       460
       +
           "hash": "sha256-l4jl4mU3bG433xSKDdCAkEqD0uUGKTOmbthhYAogcRI="

     

       466
       461
        
         },

     

       467
       462
        
         {

     

       468
       463
        
           "pname": "Microsoft.NET.Test.Sdk",

     
···

       486
       481
        
         },

     

       487
       482
        
         {

     

       488
       483
        
           "pname": "Microsoft.Testing.Extensions.Telemetry",

     

       489
       489
       -
           "version": "1.6.2",

     

       490
       490
       -
           "hash": "sha256-GZYUH+0vWAif5p4S81Oo9Tsez68ylsLjEQWhI2rgcik="

     

       484
       484
       +
           "version": "1.6.3",

     

       485
       485
       +
           "hash": "sha256-DVwTXRoWHt8Ybfz1gv/TzmX6VfxaUp9lGghDEoby0dg="

     

       491
       486
        
         },

     

       492
       487
        
         {

     

       493
       488
        
           "pname": "Microsoft.Testing.Extensions.TrxReport",

     

       494
       494
       -
           "version": "1.6.2",

     

       495
       495
       -
           "hash": "sha256-21x7FSFGVGXS8fkOQyr3jxsemxU8+7ugkVzo+mOP0Ic="

     

       489
       489
       +
           "version": "1.6.3",

     

       490
       490
       +
           "hash": "sha256-RX5m9VaXaAnmxQces8Knru7r4iHEC+EZMB0KYeXCcrc="

     

       496
       491
        
         },

     

       497
       492
        
         {

     

       498
       493
        
           "pname": "Microsoft.Testing.Extensions.TrxReport.Abstractions",

     

       499
       499
       -
           "version": "1.6.2",

     

       500
       500
       -
           "hash": "sha256-UOpDBbW3xgahofRjqdw3wUj63zXVdkIAfUE7dA4uI4Y="

     

       494
       494
       +
           "version": "1.6.3",

     

       495
       495
       +
           "hash": "sha256-gv7aCP029oku6xwYKclY5hI+ewShrk4tVFbDEND4FJI="

     

       501
       496
        
         },

     

       502
       497
        
         {

     

       503
       498
        
           "pname": "Microsoft.Testing.Extensions.VSTestBridge",

     

       504
       504
       -
           "version": "1.6.2",

     

       505
       505
       -
           "hash": "sha256-SWaSPgc2PQNqsz7ea/SQsmqOX6le6dmrDbwCHfbppZo="

     

       499
       499
       +
           "version": "1.6.3",

     

       500
       500
       +
           "hash": "sha256-4FTZCHdI9WZwd3ejeFCVbx5O0UWLJwKJc6NduUQu0XE="

     

       506
       501
        
         },

     

       507
       502
        
         {

     

       508
       503
        
           "pname": "Microsoft.Testing.Platform",

     
···

       511
       506
        
         },

     

       512
       507
        
         {

     

       513
       508
        
           "pname": "Microsoft.Testing.Platform",

     

       514
       514
       -
           "version": "1.6.2",

     

       515
       515
       -
           "hash": "sha256-RfdgATa3aTYLpGfv8ORI5uEP8dH87L5/gBDkxAG6ho4="

     

       509
       509
       +
           "version": "1.6.3",

     

       510
       510
       +
           "hash": "sha256-WJD2zC0b1jU5DRAFG3XmHiQJKdKnjDQB3xbdRmv8V9Q="

     

       516
       511
        
         },

     

       517
       512
        
         {

     

       518
       513
        
           "pname": "Microsoft.Testing.Platform.MSBuild",

     

       519
       519
       -
           "version": "1.6.2",

     

       520
       520
       -
           "hash": "sha256-bzlz10QeFrCAR+1og0gXbxSbpO64wCFrwAhBUwAp0nI="

     

       514
       514
       +
           "version": "1.6.3",

     

       515
       515
       +
           "hash": "sha256-JK8l4K4uSO6mgsZ6Lo/Sv4VjaLGZjD5g/oZYy0iAYDs="

     

       521
       516
        
         },

     

       522
       517
        
         {

     

       523
       518
        
           "pname": "Microsoft.TestPlatform.ObjectModel",

     
···

       536
       531
        
         },

     

       537
       532
        
         {

     

       538
       533
        
           "pname": "MSTest",

     

       539
       539
       -
           "version": "3.8.2",

     

       540
       540
       -
           "hash": "sha256-k6M9buNaP/y+e4/4dsSWxsFWMmocWocDh3LW1jL97/A="

     

       534
       534
       +
           "version": "3.8.3",

     

       535
       535
       +
           "hash": "sha256-Y9cVTLCQjO6j/P7Dq4/zWrF7EsVgQVnDTs5otXHzGkM="

     

       541
       536
        
         },

     

       542
       537
        
         {

     

       543
       538
        
           "pname": "MSTest.Analyzers",

     

       544
       544
       -
           "version": "3.8.2",

     

       545
       545
       -
           "hash": "sha256-r+JAxw77n/PQpQviXn8j1M+ccb9GVHTNuPWwffacVkg="

     

       539
       539
       +
           "version": "3.8.3",

     

       540
       540
       +
           "hash": "sha256-/Nf6E5zQib741BKu4IwRBz36lW9+krWLy2904MT3O1M="

     

       546
       541
        
         },

     

       547
       542
        
         {

     

       548
       543
        
           "pname": "MSTest.TestAdapter",

     

       549
       549
       -
           "version": "3.8.2",

     

       550
       550
       -
           "hash": "sha256-z5fZWSvyxvohB8Vl6gtb8nsAGt/9saXLZRckuzfVg/Y="

     

       544
       544
       +
           "version": "3.8.3",

     

       545
       545
       +
           "hash": "sha256-pBfg41vnc9z1W2uMuXRUnulGycyXJpBATsBHEiOi9mg="

     

       551
       546
        
         },

     

       552
       547
        
         {

     

       553
       548
        
           "pname": "MSTest.TestFramework",

     

       554
       554
       -
           "version": "3.8.2",

     

       555
       555
       -
           "hash": "sha256-NjQ1XU3vMRdFZSE6Ju2ASopCPZFpFZaPAQdRudqAf5c="

     

       549
       549
       +
           "version": "3.8.3",

     

       550
       550
       +
           "hash": "sha256-3dhd6vk2KdMwe+JNSoUZZ4+P04jPKBl3HTuc9ZXBTlw="

     

       556
       551
        
         },

     

       557
       552
        
         {

     

       558
       553
        
           "pname": "Newtonsoft.Json",

     
···

       601
       596
        
         },

     

       602
       597
        
         {

     

       603
       598
        
           "pname": "OpenTelemetry",

     

       604
       604
       -
           "version": "1.11.1",

     

       605
       605
       -
           "hash": "sha256-Z4U/FCSlY+qdQRS2haJDSYyxI624mDCwHZhf5At2Atk="

     

       599
       599
       +
           "version": "1.11.2",

     

       600
       600
       +
           "hash": "sha256-sQAmDGH6rQSYWNCaqgyP7qWdDciAh+IKHf4IXFwuMq4="

     

       606
       601
        
         },

     

       607
       602
        
         {

     

       608
       603
        
           "pname": "OpenTelemetry",

     
···

       611
       606
        
         },

     

       612
       607
        
         {

     

       613
       608
        
           "pname": "OpenTelemetry.Api",

     

       614
       614
       -
           "version": "1.11.1",

     

       615
       615
       -
           "hash": "sha256-1qDEHEvelvySuCPcevWgO7N9ZEmPXwnFog+tiWXr2qU="

     

       609
       609
       +
           "version": "1.11.2",

     

       610
       610
       +
           "hash": "sha256-LfsXbTxVR8f524bvIsIbLtQYxOtun4Bm3Me6IpxbvOw="

     

       616
       611
        
         },

     

       617
       612
        
         {

     

       618
       613
        
           "pname": "OpenTelemetry.Api.ProviderBuilderExtensions",

     

       619
       619
       -
           "version": "1.11.1",

     

       620
       620
       -
           "hash": "sha256-rioqazZAS6aZ7W8jJ4owu58rcnRbQyPrWVTBoqu1zPc="

     

       614
       614
       +
           "version": "1.11.2",

     

       615
       615
       +
           "hash": "sha256-p6moAb53XhkKlZ5LAy3RXPFtYFUqtOidyKJg6xzagRY="

     

       621
       616
        
         },

     

       622
       617
        
         {

     

       623
       618
        
           "pname": "OpenTelemetry.Api.ProviderBuilderExtensions",

     
···

       631
       626
        
         },

     

       632
       627
        
         {

     

       633
       628
        
           "pname": "OpenTelemetry.Extensions.Hosting",

     

       634
       634
       -
           "version": "1.11.1",

     

       635
       635
       -
           "hash": "sha256-eHQaUToWOpmJgD5XCHDCWsUcChKH3roaO8ZTAIulJVk="

     

       629
       629
       +
           "version": "1.11.2",

     

       630
       630
       +
           "hash": "sha256-z2o0gfQSZKrRDJfKrs70jmJaK3/oTqW+LSD/b+alF78="

     

       636
       631
        
         },

     

       637
       632
        
         {

     

       638
       633
        
           "pname": "OpenTelemetry.Instrumentation.AspNetCore",

     

       639
       639
       -
           "version": "1.11.0",

     

       640
       640
       -
           "hash": "sha256-F3WTwCPVUe+VppF1ZOAdBKaSseKmFZEU7D81uegqpGo="

     

       634
       634
       +
           "version": "1.11.1",

     

       635
       635
       +
           "hash": "sha256-aTXVd+zdEMJFNdRDGg01PyP4vhpDl9tpTm5GlQ2oTxU="

     

       641
       636
        
         },

     

       642
       637
        
         {

     

       643
       638
        
           "pname": "OpenTelemetry.Instrumentation.Http",

     

       644
       644
       -
           "version": "1.11.0",

     

       645
       645
       -
           "hash": "sha256-4J7ZvginaiISaLB4M9tTK2o6avBz2dSI+fAhyfraBQ4="

     

       639
       639
       +
           "version": "1.11.1",

     

       640
       640
       +
           "hash": "sha256-9bqehwixulMrjXt/ZFEosHLt6CIikLzzrdHFP5gNbzo="

     

       646
       641
        
         },

     

       647
       642
        
         {

     

       648
       643
        
           "pname": "OpenTelemetry.Instrumentation.Runtime",

     

       649
       649
       -
           "version": "1.11.0",

     

       650
       650
       -
           "hash": "sha256-VBSSJ3eORWUlVH12xzubtMtrDACAsyd1nSfgUt5ltCg="

     

       644
       644
       +
           "version": "1.11.1",

     

       645
       645
       +
           "hash": "sha256-ssHSQx/O590o/25vy+BB4KH1ChIVzQjDnwW2LnGlkm0="

     

       651
       646
        
         },

     

       652
       647
        
         {

     

       653
       648
        
           "pname": "protobuf-net",

     
···

       658
       653
        
           "pname": "protobuf-net.Core",

     

       659
       654
        
           "version": "3.2.46",

     

       660
       655
        
           "hash": "sha256-Srg7pP7rleL462idLPFUxgXBLrywWeHFyEvSV+keA4E="

     

       656
       656
       +
         },

     

       657
       657
       +
         {

     

       658
       658
       +
           "pname": "Scalar.AspNetCore",

     

       659
       659
       +
           "version": "2.1.3",

     

       660
       660
       +
           "hash": "sha256-o0rPXtulpU7y0gfQkUq9MQzud2X6A8DAJ38NPGeP5zs="

     

       661
       661
        
         },

     

       662
       662
        
         {

     

       663
       663
        
           "pname": "SteamKit2",

     
···

       665
       665
        
           "hash": "sha256-bRiLFaq/hsr+7BKtSKoD2+pf0VCGhBYe/rO3DgqMZpo="

     

       666
       666
        
         },

     

       667
       667
        
         {

     

       668
       668
       -
           "pname": "Swashbuckle.AspNetCore.SwaggerUI",

     

       669
       669
       -
           "version": "7.2.0",

     

       670
       670
       -
           "hash": "sha256-EwJsqa4JBJhMzq+zgND3STyoZi1+6GaVQqXz3ZVP7p8="

     

       671
       671
       -
         },

     

       672
       672
       -
         {

     

       673
       668
        
           "pname": "System.Buffers",

     

       674
       669
        
           "version": "4.5.1",

     

       675
       670
        
           "hash": "sha256-wws90sfi9M7kuCPWkv1CEYMJtCqx9QB/kj0ymlsNaxI="

     
···

       691
       686
        
         },

     

       692
       687
        
         {

     

       693
       688
        
           "pname": "System.Composition",

     

       694
       694
       -
           "version": "9.0.2",

     

       695
       695
       -
           "hash": "sha256-xOstum9Tv0qppXg3lq7ztv8gsSl7vvM5vp/UkrWX2Yo="

     

       689
       689
       +
           "version": "9.0.3",

     

       690
       690
       +
           "hash": "sha256-WnAxY6yJygMiHhht3/Cu2q6usvbqjy10+dnQhVAOBoc="

     

       696
       691
        
         },

     

       697
       692
        
         {

     

       698
       693
        
           "pname": "System.Composition.AttributedModel",

     

       699
       699
       -
           "version": "9.0.2",

     

       700
       700
       -
           "hash": "sha256-9y+qPVXzg8eOYaN7hp4/qtZ5WzT6NcUkO/qwenZ1wW0="

     

       694
       694
       +
           "version": "9.0.3",

     

       695
       695
       +
           "hash": "sha256-wNsQq1oshdAXZYlE3a0V+qdaSY7UAJa6XyjVEKtCzdM="

     

       701
       696
        
         },

     

       702
       697
        
         {

     

       703
       698
        
           "pname": "System.Composition.Convention",

     

       704
       704
       -
           "version": "9.0.2",

     

       705
       705
       -
           "hash": "sha256-pob6h82/AbgcNc/qYG0Yx6RNI8UtlDRX8idjZKLM6HQ="

     

       699
       699
       +
           "version": "9.0.3",

     

       700
       700
       +
           "hash": "sha256-FxDt7YeQ/n3RJbfgqhKnWxZGvAisArsWS6Nl5XN8Cm0="

     

       706
       701
        
         },

     

       707
       702
        
         {

     

       708
       703
        
           "pname": "System.Composition.Hosting",

     

       709
       709
       -
           "version": "9.0.2",

     

       710
       710
       -
           "hash": "sha256-MlTsCtJ8j+NWkGdsyw6v72AyC0BacCbB4XBeWCgfRnM="

     

       704
       704
       +
           "version": "9.0.3",

     

       705
       705
       +
           "hash": "sha256-Lshms36a63CFbBKA34tXJON2/fFy6UeAK2EcKFgGHas="

     

       711
       706
        
         },

     

       712
       707
        
         {

     

       713
       708
        
           "pname": "System.Composition.Runtime",

     

       714
       714
       -
           "version": "9.0.2",

     

       715
       715
       -
           "hash": "sha256-UZN46BXCtZWzG9HNbEQVwEmqjRfVtDpr3C+0VprKCPE="

     

       709
       709
       +
           "version": "9.0.3",

     

       710
       710
       +
           "hash": "sha256-YjWG/ugx/aEDND496fYbRVD7+lpOU7cNZFPICkHc4S0="

     

       716
       711
        
         },

     

       717
       712
        
         {

     

       718
       713
        
           "pname": "System.Composition.TypedParts",

     

       719
       719
       -
           "version": "9.0.2",

     

       720
       720
       -
           "hash": "sha256-bivrgDR31TbgugEJs79rsqmGju74NK6t6BrVDcs31es="

     

       714
       714
       +
           "version": "9.0.3",

     

       715
       715
       +
           "hash": "sha256-gMkfMOSVX0YLAtBamdHacmSBTDE+XHR2ocp5/Bwrj0U="

     

       721
       716
        
         },

     

       722
       717
        
         {

     

       723
       718
        
           "pname": "System.Diagnostics.DiagnosticSource",

     
···

       771
       766
        
         },

     

       772
       767
        
         {

     

       773
       768
        
           "pname": "System.Security.Cryptography.ProtectedData",

     

       774
       774
       -
           "version": "9.0.2",

     

       775
       775
       -
           "hash": "sha256-feZYAyRd1O1ViWDkBvkgVzCgIuPeyXgRsI+nrUqZAFc="

     

       769
       769
       +
           "version": "9.0.3",

     

       770
       770
       +
           "hash": "sha256-27A1V1ANw23BZPxSMJQsrrwQ1hruFj48DtWuyavViT4="

     

       776
       771
        
         },

     

       777
       772
        
         {

     

       778
       773
        
           "pname": "System.Security.Principal.Windows",

+3 -3

pkgs/applications/misc/ArchiSteamFarm/web-ui/default.nix

···

       7
       7
        
       

     

       8
       8
        
       buildNpmPackage rec {

     

       9
       9
        
         pname = "asf-ui";

     

       10
       10
       -
         version = "687959ad867995061641a870fb7392088929acdb";

     

       10
       10
       +
         version = "c3113782bc4895099b1a07a0e811d1e5af871ddc";

     

       11
       11
        
       

     

       12
       12
        
         src = fetchFromGitHub {

     

       13
       13
        
           owner = "JustArchiNET";

     
···

       15
       15
        
           # updated by the update script

     

       16
       16
        
           # this is always the commit that should be used with asf-ui from the latest asf version

     

       17
       17
        
           rev = version;

     

       18
       18
       -
           hash = "sha256-N2UgyVzHyombfPg+nI0O/uTAlD6Mq/pIRxdvM5bTHDE=";

     

       18
       18
       +
           hash = "sha256-B2gn40LWVm75pwV5sQpv1gRsNof9tQUDClu7oLSz/VM=";

     

       19
       19
        
         };

     

       20
       20
        
       

     

       21
       21
       -
         npmDepsHash = "sha256-TV2+84bcNIiFHxsoDfsUNzEYGLhtXZoYSWvb898X9fU=";

     

       21
       21
       +
         npmDepsHash = "sha256-Btf/S3ia8Uo/ChrKoYKRk9sKS+ZuQGtaAnaQeGDTIYI=";

     

       22
       22
        
       

     

       23
       23
        
         installPhase = ''

     

       24
       24
        
           runHook preInstall

pkgs/applications/video/mpv/scripts/simple-mpv-webui.nix

···

       20
       20
        
         };

     

       21
       21
        
         passthru.updateScript = gitUpdater { rev-prefix = "v"; };

     

       22
       22
        
       

     

       23
       23
       +
         postInstall = ''

     

       24
       24
       +
           rm -f $out/share/mpv/scripts/webui/setup.cfg

     

       25
       25
       +
         '';

     

       26
       26
       +
       

     

       23
       27
        
         scriptPath = ".";

     

       24
       28
        
         passthru.scriptName = "webui";

     

       25
       29

+3 -2

pkgs/by-name/au/authentik/package.nix

···

       15
       15
        
       }:

     

       16
       16
        
       

     

       17
       17
        
       let

     

       18
       18
       -
         version = "2025.2.1";

     

       18
       18
       +
         version = "2025.2.3";

     

       19
       19
        
       

     

       20
       20
        
         src = fetchFromGitHub {

     

       21
       21
        
           owner = "goauthentik";

     

       22
       22
        
           repo = "authentik";

     

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

     

       24
       24
       -
           hash = "sha256-KZalpsM9rvki9GD+urf8idHOEnvBJtkSvE1b2b4KL/4=";

     

       24
       24
       +
           hash = "sha256-aaSAlFIc5Gn5PJPVuObi24Y86/3N3yFJVQTx1tV2i2A=";

     

       25
       25
        
         };

     

       26
       26
        
       

     

       27
       27
        
         meta = with lib; {

     
···

       30
       30
        
           homepage = "https://goauthentik.io/";

     

       31
       31
        
           license = licenses.mit;

     

       32
       32
        
           platforms = platforms.linux;

     

       33
       33
       +
           broken = stdenvNoCC.hostPlatform.isAarch64;

     

       33
       34
        
           maintainers = with maintainers; [

     

       34
       35
        
             jvanbruegge

     

       35
       36
        
             risson

+5 -5

pkgs/by-name/co/codeium/package.nix

···

       23
       23
        
       

     

       24
       24
        
         hash =

     

       25
       25
        
           {

     

       26
       26
       -
             x86_64-linux = "sha256-xczcogpRXdFX34uAjbERWf9lj3uxLKpPlceyZ7KgTz0=";

     

       27
       27
       -
             aarch64-linux = "sha256-8Ju1qUGc68xxj7ikoAQzic5tdnnemhIo/UU2G55npeE=";

     

       28
       28
       -
             x86_64-darwin = "sha256-pJZxykfeQaaNFrP3x1Hj2huWngOQc3F4KjtGV8Rae8s=";

     

       29
       29
       -
             aarch64-darwin = "sha256-jEMgFbOy65wCLxcA961u3jFwav+KVSrpDYcvt/4Ea8A=";

     

       26
       26
       +
             x86_64-linux = "sha256-iFJRdECSmFZt63yVkozaZeIT0MP8vfW3G5SvuE8/wZw=";

     

       27
       27
       +
             aarch64-linux = "sha256-JJxjYFgaj2f6RQRszWfxG26SjTokhoGDZjqbg7HGoV0=";

     

       28
       28
       +
             x86_64-darwin = "sha256-27bhqNIw3Aceq8u0UthR5Ju20SQiGVMCfUZiHbzC6wk=";

     

       29
       29
       +
             aarch64-darwin = "sha256-wajMCeRaOzXSJgb5z8i+ed+2w0xWTm0I2Wb3hTq1LqY=";

     

       30
       30
        
           }

     

       31
       31
        
           .${system} or throwSystem;

     

       32
       32
        
       

     
···

       35
       35
        
       in

     

       36
       36
        
       stdenv.mkDerivation (finalAttrs: {

     

       37
       37
        
         pname = "codeium";

     

       38
       38
       -
         version = "1.42.3";

     

       38
       38
       +
         version = "1.42.4";

     

       39
       39
        
         src = fetchurl {

     

       40
       40
        
           name = "${finalAttrs.pname}-${finalAttrs.version}.gz";

     

       41
       41
        
           url = "https://github.com/Exafunction/codeium/releases/download/language-server-v${finalAttrs.version}/language_server_${plat}.gz";

+2 -2

pkgs/by-name/fa/fastfetch/package.nix

···

       45
       45
        
       }:

     

       46
       46
        
       stdenv.mkDerivation (finalAttrs: {

     

       47
       47
        
         pname = "fastfetch";

     

       48
       48
       -
         version = "2.39.1";

     

       48
       48
       +
         version = "2.40.0";

     

       49
       49
        
       

     

       50
       50
        
         src = fetchFromGitHub {

     

       51
       51
        
           owner = "fastfetch-cli";

     

       52
       52
        
           repo = "fastfetch";

     

       53
       53
        
           tag = finalAttrs.version;

     

       54
       54
       -
           hash = "sha256-7ukbYmfhfdjzooHA9J/AixfkZrzJZvnoHGg4z2jCZPI=";

     

       54
       54
       +
           hash = "sha256-+eCoxWzTUPLYkz05XwJW1i8v5tyO3VRlm/ZKSlP3cts=";

     

       55
       55
        
         };

     

       56
       56
        
       

     

       57
       57
        
         outputs = [

+8 -7

pkgs/by-name/ga/gappa/package.nix

···

       5
       5
        
         gmp,

     

       6
       6
        
         mpfr,

     

       7
       7
        
         boost,

     

       8
       8
       +
         version ? "1.6.0",

     

       8
       9
        
       }:

     

       9
       10
        
       

     

       10
       10
       -
       stdenv.mkDerivation rec {

     

       11
       11
       +
       stdenv.mkDerivation {

     

       11
       12
        
         pname = "gappa";

     

       12
       12
       -
         version = "1.4.0";

     

       13
       13
       +
         inherit version;

     

       13
       14
        
       

     

       14
       15
        
         src = fetchurl {

     

       15
       15
       -
           url = "https://gforge.inria.fr/frs/download.php/file/38436/gappa-${version}.tar.gz";

     

       16
       16
       -
           sha256 = "12x42z901pr05ldmparqdi8sq9s7fxbavhzk2dbq3l6hy247dwbb";

     

       16
       16
       +
           url = "https://gappa.gitlabpages.inria.fr/releases/gappa-${version}.tar.gz";

     

       17
       17
       +
           hash = "sha256-aNht0Ttv+gzS9eLzu4PQitRK/zQN9QQ4YOEjQ2d9xIM=";

     

       17
       18
        
         };

     

       18
       19
        
       

     

       19
       20
        
         buildInputs = [

     
···

       26
       27
        
         installPhase = "./remake install";

     

       27
       28
        
       

     

       28
       29
        
         meta = {

     

       29
       29
       -
           homepage = "http://gappa.gforge.inria.fr/";

     

       30
       30
       +
           homepage = "https://gappa.gitlabpages.inria.fr/";

     

       30
       31
        
           description = "Verifying and formally proving properties on numerical programs dealing with floating-point or fixed-point arithmetic";

     

       31
       32
        
           mainProgram = "gappa";

     

       32
       33
        
           license = with lib.licenses; [

     

       33
       33
       -
             cecill20

     

       34
       34
       -
             gpl2

     

       34
       34
       +
             cecill21

     

       35
       35
       +
             gpl3

     

       35
       36
        
           ];

     

       36
       37
        
           maintainers = with lib.maintainers; [ vbgl ];

     

       37
       38
        
           platforms = lib.platforms.all;

+7 -12

pkgs/by-name/he/hexxy/package.nix

···

       4
       4
        
         fetchFromGitHub,

     

       5
       5
        
         nix-update-script,

     

       6
       6
        
       }:

     

       7
       7
       -
       buildGoModule {

     

       7
       7
       +
       buildGoModule (finalAttrs: {

     

       8
       8
        
         pname = "hexxy";

     

       9
       9
       -
         version = "0-unstable-2025-03-16";

     

       9
       9
       +
         version = "0.1.1";

     

       10
       10
        
         src = fetchFromGitHub {

     

       11
       11
        
           owner = "sweetbbak";

     

       12
       12
        
           repo = "hexxy";

     

       13
       13
       -
           # upstream does not publish releases, i.e., there are no tags

     

       14
       14
       -
           rev = "d90f345ba80078b18baf006b3a5aec92d2c330e1";

     

       15
       15
       -
           hash = "sha256-htTGdcJ3oMgfsJ3FH1aRnI2vxMNpBcLksABA75EQUFo=";

     

       13
       13
       +
       

     

       14
       14
       +
           tag = "v${finalAttrs.version}";

     

       15
       15
       +
           hash = "sha256-pboOpPGqlSWSiP6yWONxC3wbrGc8FN0++5vHd4ERbkA=";

     

       16
       16
        
         };

     

       17
       17
        
       

     

       18
       18
        
         vendorHash = "sha256-qkBpSVLWZPRgS9bqOVUWHpyj8z/nheQJON3vJOwPUj4=";

     
···

       21
       21
        
           "-w"

     

       22
       22
        
         ];

     

       23
       23
        
       

     

       24
       24
       -
         passthru.updateScript = nix-update-script {

     

       25
       25
       -
           extraArgs = [

     

       26
       26
       -
             "--version"

     

       27
       27
       -
             "branch"

     

       28
       28
       -
           ];

     

       29
       29
       -
         };

     

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

     

       30
       25
        
       

     

       31
       26
        
         meta = {

     

       32
       27
        
           description = "A modern and beautiful alternative to xxd and hexdump";

     
···

       35
       30
        
           maintainers = [ lib.maintainers.NotAShelf ];

     

       36
       31
        
           mainProgram = "hexxy";

     

       37
       32
        
         };

     

       38
       38
       -
       }

     

       33
       33
       +
       })

+18 -8

pkgs/by-name/ki/kitty/package.nix

···

       44
       44
        
         zsh,

     

       45
       45
        
         fish,

     

       46
       46
        
         nixosTests,

     

       47
       47
       -
         go_1_23,

     

       48
       48
       -
         buildGo123Module,

     

       47
       47
       +
         go_1_24,

     

       48
       48
       +
         buildGo124Module,

     

       49
       49
        
         nix-update-script,

     

       50
       50
        
         makeBinaryWrapper,

     

       51
       51
        
         autoSignDarwinBinariesHook,

     
···

       56
       56
        
       with python3Packages;

     

       57
       57
        
       buildPythonApplication rec {

     

       58
       58
        
         pname = "kitty";

     

       59
       59
       -
         version = "0.40.1";

     

       59
       59
       +
         version = "0.41.1";

     

       60
       60
        
         format = "other";

     

       61
       61
        
       

     

       62
       62
        
         src = fetchFromGitHub {

     

       63
       63
        
           owner = "kovidgoyal";

     

       64
       64
        
           repo = "kitty";

     

       65
       65
        
           tag = "v${version}";

     

       66
       66
       -
           hash = "sha256-ta9MTbSkIkowkd5zBUbtauFNGVRDgxof1SSQXuEgFTQ=";

     

       66
       66
       +
           hash = "sha256-oTkzFEPgbFa2wPBJxh/9ZbK8liM9isWGEwExJq5/h2o=";

     

       67
       67
        
         };

     

       68
       68
        
       

     

       69
       69
        
         goModules =

     

       70
       70
       -
           (buildGo123Module {

     

       70
       70
       +
           (buildGo124Module {

     

       71
       71
        
             pname = "kitty-go-modules";

     

       72
       72
        
             inherit src version;

     

       73
       73
       -
             vendorHash = "sha256-wr5R2X+lV8vVVWsDYLLSaz7HRNOB7Zzk/a7knsdDlXs=";

     

       73
       73
       +
             vendorHash = "sha256-ld3cGJUjoi3od6gINyGE7fQodl9CSKmakJ1CPLMX+Ss=";

     

       74
       74
        
           }).goModules;

     

       75
       75
        
       

     

       76
       76
        
         buildInputs =

     
···

       124
       124
        
             sphinx-copybutton

     

       125
       125
        
             sphinxext-opengraph

     

       126
       126
        
             sphinx-inline-tabs

     

       127
       127
       -
             go_1_23

     

       127
       127
       +
             go_1_24

     

       128
       128
        
             fontconfig

     

       129
       129
        
             makeBinaryWrapper

     

       130
       130
        
           ]

     
···

       231
       231
        
       

     

       232
       232
        
         # skip failing tests due to darwin sandbox

     

       233
       233
        
         preCheck = lib.optionalString stdenv.hostPlatform.isDarwin ''

     

       234
       234
       -
           # can be re-enabled with the next kitty release, see https://github.com/kovidgoyal/kitty/pull/7939

     

       234
       234
       +
       

     

       235
       235
        
           substituteInPlace kitty_tests/file_transmission.py \

     

       236
       236
        
             --replace test_transfer_send dont_test_transfer_send

     

       237
       237
       +
       

     

       238
       238
       +
           substituteInPlace kitty_tests/ssh.py \

     

       239
       239
       +
             --replace test_ssh_connection_data no_test_ssh_connection_data \

     

       240
       240
       +
       

     

       241
       241
       +
           substituteInPlace kitty_tests/shell_integration.py \

     

       242
       242
       +
             --replace test_fish_integration no_test_fish_integration

     

       243
       243
       +
       

     

       244
       244
       +
           substituteInPlace kitty_tests/fonts.py \

     

       245
       245
       +
             --replace test_fallback_font_not_last_resort no_test_fallback_font_not_last_resort

     

       246
       246
       +
       

     

       237
       247
        
           # theme collection test starts an http server

     

       238
       248
        
           rm tools/themes/collection_test.go

     

       239
       249
        
           # passwd_test tries to exec /usr/bin/dscl

pkgs/by-name/li/libbytesize/package.nix

···

       60
       60
        
         postInstall = ''

     

       61
       61
        
           substituteInPlace $out/${python3Packages.python.sitePackages}/bytesize/bytesize.py \

     

       62
       62
        
             --replace-fail 'CDLL("libbytesize.so.1")' "CDLL('$out/lib/libbytesize.so.1')"

     

       63
       63
       +
       

     

       64
       64
       +
           # Force compilation of .pyc files to make them deterministic

     

       65
       65
       +
           ${python3Packages.python.interpreter} -m compileall $out/${python3Packages.python.sitePackages}/bytesize

     

       63
       66
        
         '';

     

       64
       67
        
       

     

       65
       68
        
         pythonImportsCheck = [ "bytesize" ];

+3 -3

pkgs/by-name/lo/lowfi/package.nix

···

       11
       11
        
       

     

       12
       12
        
       rustPlatform.buildRustPackage rec {

     

       13
       13
        
         pname = "lowfi";

     

       14
       14
       -
         version = "1.5.6";

     

       14
       14
       +
         version = "1.6.0";

     

       15
       15
        
       

     

       16
       16
        
         src = fetchFromGitHub {

     

       17
       17
        
           owner = "talwat";

     

       18
       18
        
           repo = "lowfi";

     

       19
       19
        
           tag = version;

     

       20
       20
       -
           hash = "sha256-lR22UN9LiuJknq2KTNOXcybXwi2KvLRe0KHocFWL0GM=";

     

       20
       20
       +
           hash = "sha256-t3Lbqrcmh0XSOO+hc4UsWhKi4zToORFQo0A4G32aeOw=";

     

       21
       21
        
         };

     

       22
       22
        
       

     

       23
       23
        
         useFetchCargoVendor = true;

     

       24
       24
       -
         cargoHash = "sha256-xMksujaZgOPJsBiv6//4zeiUcWEV2Pc7daBaPUh3cYc=";

     

       24
       24
       +
         cargoHash = "sha256-waQcxdVXZZ09wuLWUNL4nRUHF1rIDI8lAfYc/1bxMl0=";

     

       25
       25
        
       

     

       26
       26
        
         buildFeatures = [ "mpris" ];

     

       27
       27

+26 -12

pkgs/by-name/mj/mjmap/package.nix

···

       2
       2
        
         lib,

     

       3
       3
        
         buildGoModule,

     

       4
       4
        
         fetchFromSourcehut,

     

       5
       5
       -
         unstableGitUpdater,

     

       5
       5
       +
         scdoc,

     

       6
       6
       +
         installShellFiles,

     

       7
       7
       +
         versionCheckHook,

     

       8
       8
       +
         nix-update-script,

     

       6
       9
        
       }:

     

       7
       10
        
       

     

       11
       11
       +
       let

     

       12
       12
       +
         version = "1.0.1";

     

       13
       13
       +
       in

     

       14
       14
       +
       

     

       8
       15
        
       buildGoModule {

     

       9
       16
        
         pname = "mjmap";

     

       10
       10
       -
         version = "0.1.0-unstable-2025-03-06";

     

       17
       17
       +
         inherit version;

     

       11
       18
        
       

     

       12
       19
        
         src = fetchFromSourcehut {

     

       13
       20
        
           owner = "~rockorager";

     

       14
       21
        
           repo = "mjmap";

     

       15
       15
       -
           rev = "fdc1658f1a3d57594479535692ed06c6e19cc859";

     

       16
       16
       -
           hash = "sha256-178S4Y4h31z0OCedS44udxyv8TfgZoDykApg3pX15oQ=";

     

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

     

       23
       23
       +
           hash = "sha256-VV+bZ01l+uEe3wqdYyVwpzsZJNzoTCD38F6a58dozbg=";

     

       17
       24
        
         };

     

       18
       25
        
       

     

       19
       19
       -
         vendorHash = "sha256-fJuPrzjRH0FpYj2D9CsFdsdzYT0C3/D2PhmJIZTsgfQ=";

     

       26
       26
       +
         vendorHash = "sha256-sZsS8q/hkA2T/8QmtKzNof0mzCuWYin227+/7k3XTM0=";

     

       20
       27
        
       

     

       21
       21
       -
         installCheckPhase = ''

     

       22
       22
       -
           runHook preInstallCheck

     

       28
       28
       +
         nativeBuildInputs = [

     

       29
       29
       +
           scdoc

     

       30
       30
       +
           installShellFiles

     

       31
       31
       +
         ];

     

       23
       32
        
       

     

       24
       24
       -
           $out/bin/mjmap --version >/dev/null

     

       33
       33
       +
         nativeInstallCheckInputs = [ versionCheckHook ];

     

       34
       34
       +
       

     

       35
       35
       +
         versionCheckProgram = "mjmap";

     

       36
       36
       +
       

     

       37
       37
       +
         postBuild = ''

     

       38
       38
       +
           make mjmap.1

     

       39
       39
       +
         '';

     

       25
       40
        
       

     

       26
       26
       -
           runHook postInstallCheck

     

       41
       41
       +
         postInstall = ''

     

       42
       42
       +
           installManPage mjmap.1

     

       27
       43
        
         '';

     

       28
       44
        
       

     

       29
       29
       -
         passthru.updateScript = unstableGitUpdater {

     

       30
       30
       -
           tagPrefix = "v.";

     

       31
       31
       -
         };

     

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

     

       32
       46
        
       

     

       33
       47
        
         meta = {

     

       34
       48
        
           description = "Sendmail‐compatible JMAP client";

+3 -3

pkgs/by-name/nr/nrr/package.nix

···

       7
       7
        
       }:

     

       8
       8
        
       rustPlatform.buildRustPackage rec {

     

       9
       9
        
         pname = "nrr";

     

       10
       10
       -
         version = "0.10.1";

     

       10
       10
       +
         version = "0.10.2";

     

       11
       11
        
       

     

       12
       12
        
         src = fetchFromGitHub {

     

       13
       13
        
           owner = "ryanccn";

     

       14
       14
        
           repo = "nrr";

     

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

     

       16
       16
       -
           hash = "sha256-9QoYkYuN9kbcjgjn+7CuqKOKrVaPu8U2W/4KB+M04hg=";

     

       16
       16
       +
           hash = "sha256-qh4YEfdfO6WofdrFHVDvkNocloK2LuWelfZPilxiKPk=";

     

       17
       17
        
         };

     

       18
       18
        
       

     

       19
       19
        
         useFetchCargoVendor = true;

     

       20
       20
       -
         cargoHash = "sha256-ZAGR7Slpt3uUWO7g4GFr7tn8/fYeAxPYZivKAhLkar4=";

     

       20
       20
       +
         cargoHash = "sha256-f8ugfkTtS23TLh0Ss4SpxGy1Y9AeqinE+psDmHVHibg=";

     

       21
       21
        
       

     

       22
       22
        
         env = lib.optionalAttrs enableLTO {

     

       23
       23
        
           CARGO_PROFILE_RELEASE_LTO = "fat";

+5 -23

pkgs/by-name/op/opentofu/package.nix

···

       108
       108
        
         withPlugins =

     

       109
       109
        
           plugins:

     

       110
       110
        
           let

     

       111
       111
       -
             actualPlugins = lib.lists.map (

     

       112
       112
       -
               provider:

     

       113
       113
       -
               if provider ? override then

     

       114
       114
       -
                 # use opentofu plugin registry over terraform's

     

       115
       115
       -
                 provider.override (

     

       116
       116
       -
                   oldArgs:

     

       117
       117
       -
                   if (builtins.hasAttr "homepage" oldArgs) then

     

       118
       118
       -
                     {

     

       119
       119
       -
                       provider-source-address =

     

       120
       120
       -
                         lib.replaceStrings

     

       121
       121
       -
                           [ "https://registry.terraform.io/providers" ]

     

       122
       122
       -
                           [

     

       123
       123
       -
                             "registry.opentofu.org"

     

       124
       124
       -
                           ]

     

       125
       125
       -
                           oldArgs.homepage;

     

       126
       126
       -
                     }

     

       127
       127
       -
                   else

     

       128
       128
       -
                     { }

     

       129
       129
       -
                 )

     

       130
       130
       -
               else

     

       131
       131
       -
                 provider

     

       132
       132
       -
             ) (plugins package.plugins);

     

       111
       111
       +
             actualPlugins = plugins package.plugins;

     

       133
       112
        
       

     

       134
       113
        
             # Wrap PATH of plugins propagatedBuildInputs, plugins may have runtime dependencies on external binaries

     

       135
       114
        
             wrapperInputs = lib.unique (

     
···

       183
       162
        
                 passthru = package.passthru // passthru;

     

       184
       163
        
       

     

       185
       164
        
                 buildCommand = ''

     

       186
       186
       -
                   # Create wrappers for terraform plugins because Terraform only

     

       165
       165
       +
                   # Create wrappers for terraform plugins because OpenTofu only

     

       187
       166
        
                   # walks inside of a tree of files.

     

       167
       167
       +
                   # Also replace registry.terraform.io dir with registry.opentofu.org,

     

       168
       168
       +
                   # so OpenTofu can find the plugins.

     

       188
       169
        
                   for providerDir in ${toString actualPlugins}

     

       189
       170
        
                   do

     

       190
       171
        
                     for file in $(find $providerDir/libexec/terraform-providers -type f)

     

       191
       172
        
                     do

     

       192
       173
        
                       relFile=''${file#$providerDir/}

     

       174
       174
       +
                       relFile=''${relFile/registry.terraform.io/registry.opentofu.org}

     

       193
       175
        
                       mkdir -p $out/$(dirname $relFile)

     

       194
       176
        
                       cat <<WRAPPER > $out/$relFile

     

       195
       177
        
                   #!${runtimeShell}

+2 -2

pkgs/by-name/qu/quill-log/package.nix

···

       7
       7
        
       

     

       8
       8
        
       stdenv.mkDerivation rec {

     

       9
       9
        
         pname = "quill-log";

     

       10
       10
       -
         version = "8.2.0";

     

       10
       10
       +
         version = "9.0.0";

     

       11
       11
        
       

     

       12
       12
        
         src = fetchFromGitHub {

     

       13
       13
        
           owner = "odygrd";

     

       14
       14
        
           repo = "quill";

     

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

     

       16
       16
       -
           hash = "sha256-q61TdttCVZG5MZVhokugMGhB4ZJOhK4iFgirUonocJg=";

     

       16
       16
       +
           hash = "sha256-WkJOB06yH3B3L2aqglh1jc38e1fDbxaqFEEh1AvBUcw=";

     

       17
       17
        
         };

     

       18
       18
        
       

     

       19
       19
        
         nativeBuildInputs = [ cmake ];

+2 -2

pkgs/by-name/re/remind/package.nix

···

       16
       16
        
       

     

       17
       17
        
       tcl.mkTclDerivation rec {

     

       18
       18
        
         pname = "remind";

     

       19
       19
       -
         version = "05.03.04";

     

       19
       19
       +
         version = "05.03.05";

     

       20
       20
        
       

     

       21
       21
        
         src = fetchFromGitea {

     

       22
       22
        
           domain = "git.skoll.ca";

     

       23
       23
        
           owner = "Skollsoft-Public";

     

       24
       24
        
           repo = "Remind";

     

       25
       25
        
           rev = version;

     

       26
       26
       -
           hash = "sha256-6pUQONmafwfUZ3DAsYS6dju8mLE9piu7btPmP6QX4pM=";

     

       26
       26
       +
           hash = "sha256-dMnsMV4DRxXWgev9LCb4wwdnx7A++giCsW7c2cMde9Q=";

     

       27
       27
        
         };

     

       28
       28
        
       

     

       29
       29
        
         propagatedBuildInputs = lib.optionals withGui [

+3 -3

pkgs/by-name/tr/traefik/package.nix

···

       7
       7
        
       

     

       8
       8
        
       buildGo123Module rec {

     

       9
       9
        
         pname = "traefik";

     

       10
       10
       -
         version = "3.3.3";

     

       10
       10
       +
         version = "3.3.4";

     

       11
       11
        
       

     

       12
       12
        
         # Archive with static assets for webui

     

       13
       13
        
         src = fetchzip {

     

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

     

       15
       15
       -
           hash = "sha256-R9fiCLqzrd9SS6LoQt3jOoEchRnPuhmJqIob8JhzqEU=";

     

       15
       15
       +
           hash = "sha256-KXFpdk1VMYzGldFp/b5Ss6aJvL9yG4kSbM4LOIBUL5A=";

     

       16
       16
        
           stripRoot = false;

     

       17
       17
        
         };

     

       18
       18
        
       

     

       19
       19
       -
         vendorHash = "sha256-9WuhQjl+lWRZBvEP8qjBQUbEQC1SG9J+3xNpmIieOo8=";

     

       19
       19
       +
         vendorHash = "sha256-wtZFViVNvNuhHvI1YR2ome1rs2DIAd3Iurmpi9Y6F2w=";

     

       20
       20
        
       

     

       21
       21
        
         subPackages = [ "cmd/traefik" ];

     

       22
       22

+2 -2

pkgs/by-name/va/vale/package.nix

···

       11
       11
        
       

     

       12
       12
        
       buildGoModule rec {

     

       13
       13
        
         pname = "vale";

     

       14
       14
       -
         version = "3.10.0";

     

       14
       14
       +
         version = "3.11.0";

     

       15
       15
        
       

     

       16
       16
        
         subPackages = [ "cmd/vale" ];

     

       17
       17
        
       

     
···

       19
       19
        
           owner = "errata-ai";

     

       20
       20
        
           repo = "vale";

     

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

     

       22
       22
       -
           hash = "sha256-aZ+ihq4ft6HpKBZu7idq0m298WSxBubuEsIPNLvu1RU=";

     

       22
       22
       +
           hash = "sha256-NJ8QmF2ZGlbkHhc0OQSVl11pQDHO88KL/MLr+8ABLYs=";

     

       23
       23
        
         };

     

       24
       24
        
       

     

       25
       25
        
         vendorHash = "sha256-Zhhp/qbwGTQEZ28S+p7GJodwQcnkFNqNU7WCZKdeoz0=";

+63

pkgs/by-name/xe/xee/package.nix

···

       1
       1
       +
       {

     

       2
       2
       +
         lib,

     

       3
       3
       +
         rustPlatform,

     

       4
       4
       +
         fetchFromGitHub,

     

       5
       5
       +
         writers,

     

       6
       6
       +
         versionCheckHook,

     

       7
       7
       +
       }:

     

       8
       8
       +
       

     

       9
       9
       +
       rustPlatform.buildRustPackage (finalAttrs: {

     

       10
       10
       +
         pname = "xee";

     

       11
       11
       +
         version = "0.1.5";

     

       12
       12
       +
       

     

       13
       13
       +
         src = fetchFromGitHub {

     

       14
       14
       +
           owner = "Paligo";

     

       15
       15
       +
           repo = "xee";

     

       16
       16
       +
           tag = "xee-v${finalAttrs.version}";

     

       17
       17
       +
           hash = "sha256-l5g2YZ4lNu+CLyya0FavDEqbJayaTXGrB8fYCr3fj0s=";

     

       18
       18
       +
         };

     

       19
       19
       +
       

     

       20
       20
       +
         useFetchCargoVendor = true;

     

       21
       21
       +
         cargoHash = "sha256-Ora6VwYLDyFI4iA4FkygGsup8I4OvK0kkLvHs4F/YhY=";

     

       22
       22
       +
       

     

       23
       23
       +
         cargoBuildFlags = [

     

       24
       24
       +
           "--package"

     

       25
       25
       +
           "xee"

     

       26
       26
       +
         ];

     

       27
       27
       +
       

     

       28
       28
       +
         nativeBuildInputs = [

     

       29
       29
       +
           # "${cargoDeps}/build-data-0.2.1/src/lib.rs" is pretty terrible

     

       30
       30
       +
           (writers.writePython3Bin "git" { } ''

     

       31
       31
       +
             import sys

     

       32
       32
       +
             import os

     

       33
       33
       +
             sys.argv[0] = os.path.basename(sys.argv[0])

     

       34
       34
       +
             if sys.argv == ["git", "rev-parse", "HEAD"]:

     

       35
       35
       +
                 print("${finalAttrs.src.rev}")

     

       36
       36
       +
             elif sys.argv == ["git", "rev-parse", "--abbrev-ref=loose", "HEAD"]:

     

       37
       37
       +
                 print("${finalAttrs.src.rev}")

     

       38
       38
       +
             elif sys.argv == ["git", "status", "-s"]:

     

       39
       39
       +
                 pass

     

       40
       40
       +
             elif sys.argv == ["git", "log", "-1", "--pretty=%ct"]:

     

       41
       41
       +
                 print(os.environ.get("SOURCE_DATE_EPOCH", "0"))

     

       42
       42
       +
             else:

     

       43
       43
       +
                 raise RuntimeError(sys.argv[1:])

     

       44
       44
       +
           '')

     

       45
       45
       +
         ];

     

       46
       46
       +
       

     

       47
       47
       +
         doInstallCheck = true;

     

       48
       48
       +
         nativeInstallCheckInputs = [ versionCheckHook ];

     

       49
       49
       +
         versionCheckProgramArg = "--version";

     

       50
       50
       +
       

     

       51
       51
       +
         meta = {

     

       52
       52
       +
           description = "XML Execution Engine written in Rust.";

     

       53
       53
       +
           longDescription = ''

     

       54
       54
       +
             Load XML documents, issue XPath expressions against them, including in

     

       55
       55
       +
             a REPL, and pretty-print XML documents. A Swiss Army knife CLI for XML.

     

       56
       56
       +
           '';

     

       57
       57
       +
           homepage = "https://github.com/Paligo/xee";

     

       58
       58
       +
           changelog = "https://github.com/Paligo/xee/releases/tag/xee-v${finalAttrs.version}";

     

       59
       59
       +
           license = lib.licenses.mit;

     

       60
       60
       +
           maintainers = with lib.maintainers; [ pbsds ];

     

       61
       61
       +
           mainProgram = "xee";

     

       62
       62
       +
         };

     

       63
       63
       +
       })

+2 -2

pkgs/data/fonts/font-awesome/default.nix

···

       61
       61
        
           hash = "sha256-gd23ZplNY56sm1lfkU3kPXUOmNmY5SRnT0qlQZRNuBo=";

     

       62
       62
        
         };

     

       63
       63
        
         v6 = font-awesome {

     

       64
       64
       -
           version = "6.7.1";

     

       65
       65
       -
           hash = "sha256-Lzy12F0qEGzvdyN9SC3nyh2eTc80HM4qR5U6h0G15bo=";

     

       64
       64
       +
           version = "6.7.2";

     

       65
       65
       +
           hash = "sha256-MaJG96kYj8ukJVyqOTDpkHH/eWr/ZlbVKk9AvJM7ub4=";

     

       66
       66
        
         };

     

       67
       67
        
       }

+2 -2

pkgs/development/embedded/platformio/default.nix

···

       1
       1
       -
       { newScope, python3Packages }:

     

       1
       1
       +
       { newScope }:

     

       2
       2
        
       

     

       3
       3
        
       let

     

       4
       4
        
         callPackage = newScope self;

     

       5
       5
        
       

     

       6
       6
        
         self = {

     

       7
       7
       -
           platformio-core = python3Packages.callPackage ./core.nix { };

     

       7
       7
       +
           platformio-core = callPackage ./core.nix { };

     

       8
       8
        
       

     

       9
       9
        
           platformio-chrootenv = callPackage ./chrootenv.nix { };

     

       10
       10
        
         };

+4 -3

pkgs/development/libraries/cxxtest/default.nix

···

       1
       1
        
       {

     

       2
       2
        
         lib,

     

       3
       3
       -
         python3Packages,

     

       3
       3
       +
         buildPythonApplication,

     

       4
       4
        
         fetchFromGitHub,

     

       5
       5
       +
         ply,

     

       5
       6
        
       }:

     

       6
       7
        
       

     

       7
       7
       -
       python3Packages.buildPythonApplication rec {

     

       8
       8
       +
       buildPythonApplication rec {

     

       8
       9
        
         pname = "cxxtest";

     

       9
       10
        
         version = "4.4";

     

       10
       11
        
       

     
···

       17
       18
        
       

     

       18
       19
        
         sourceRoot = "${src.name}/python";

     

       19
       20
        
       

     

       20
       20
       -
         nativeCheckInputs = [ python3Packages.ply ];

     

       21
       21
       +
         nativeCheckInputs = [ ply ];

     

       21
       22
        
       

     

       22
       23
        
         preCheck = ''

     

       23
       24
        
           cd ../

+2 -2

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

···

       22
       22
        
       

     

       23
       23
        
       buildPythonPackage rec {

     

       24
       24
        
         pname = "pymc";

     

       25
       25
       -
         version = "5.21.1";

     

       25
       25
       +
         version = "5.22.0";

     

       26
       26
        
         pyproject = true;

     

       27
       27
        
       

     

       28
       28
        
         src = fetchFromGitHub {

     

       29
       29
        
           owner = "pymc-devs";

     

       30
       30
        
           repo = "pymc";

     

       31
       31
        
           tag = "v${version}";

     

       32
       32
       -
           hash = "sha256-XwStIPjhCw3Vf8jAMG7x8uc/t4h1JYTDz4Lobv/nS1g=";

     

       32
       32
       +
           hash = "sha256-NQYvtt/cjssJ7Lv3RyDeBMQByKMmt1p0X9F+LqhtTV4=";

     

       33
       33
        
         };

     

       34
       34
        
       

     

       35
       35
        
         build-system = [

+48

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

···

       1
       1
       +
       {

     

       2
       2
       +
         lib,

     

       3
       3
       +
         beautifulsoup4,

     

       4
       4
       +
         buildPythonPackage,

     

       5
       5
       +
         fetchFromGitHub,

     

       6
       6
       +
         httpx,

     

       7
       7
       +
         rich,

     

       8
       8
       +
         setuptools,

     

       9
       9
       +
       }:

     

       10
       10
       +
       

     

       11
       11
       +
       buildPythonPackage rec {

     

       12
       12
       +
         pname = "pyporscheconnectapi";

     

       13
       13
       +
         version = "0.2.3";

     

       14
       14
       +
         pyproject = true;

     

       15
       15
       +
       

     

       16
       16
       +
         src = fetchFromGitHub {

     

       17
       17
       +
           owner = "CJNE";

     

       18
       18
       +
           repo = "pyporscheconnectapi";

     

       19
       19
       +
           tag = version;

     

       20
       20
       +
           hash = "sha256-MQYhIp+DUYcRKAEwcT8qzrFY043b33BHR8jma3jR0lE=";

     

       21
       21
       +
         };

     

       22
       22
       +
       

     

       23
       23
       +
         postPatch = ''

     

       24
       24
       +
           substituteInPlace setup.py \

     

       25
       25
       +
             --replace-fail '"pytest-runner"' ""

     

       26
       26
       +
         '';

     

       27
       27
       +
       

     

       28
       28
       +
         build-system = [ setuptools ];

     

       29
       29
       +
       

     

       30
       30
       +
         dependencies = [

     

       31
       31
       +
           beautifulsoup4

     

       32
       32
       +
           httpx

     

       33
       33
       +
           rich

     

       34
       34
       +
         ];

     

       35
       35
       +
       

     

       36
       36
       +
         # Module has no tests

     

       37
       37
       +
         doCheck = false;

     

       38
       38
       +
       

     

       39
       39
       +
         pythonImportsCheck = [ "pyporscheconnectapi" ];

     

       40
       40
       +
       

     

       41
       41
       +
         meta = {

     

       42
       42
       +
           description = "Python client library for Porsche Connect API";

     

       43
       43
       +
           homepage = "https://github.com/CJNE/pyporscheconnectapi";

     

       44
       44
       +
           changelog = "https://github.com/CJNE/pyporscheconnectapi/releases/tag/${src.tag}";

     

       45
       45
       +
           license = lib.licenses.mit;

     

       46
       46
       +
           maintainers = with lib.maintainers; [ fab ];

     

       47
       47
       +
         };

     

       48
       48
       +
       }

+12 -14

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

···

       5
       5
        
         numpy,

     

       6
       6
        
         scipy,

     

       7
       7
        
         pillow,

     

       8
       8
       +
         pywavelets,

     

       8
       9
        
         fetchpatch,

     

       9
       10
        
       }:

     

       10
       11
        
       

     

       11
       12
        
       buildPythonPackage rec {

     

       12
       13
        
         pname = "pyssim";

     

       13
       13
       -
         version = "0.6";

     

       14
       14
       +
         version = "0.7";

     

       14
       15
        
         format = "setuptools";

     

       15
       16
        
       

     

       16
       16
       -
         propagatedBuildInputs = [

     

       17
       17
       +
         dependencies = [

     

       17
       18
        
           numpy

     

       18
       19
        
           scipy

     

       19
       20
        
           pillow

     

       21
       21
       +
           pywavelets

     

       20
       22
        
         ];

     

       21
       23
        
       

     

       22
       24
        
         # PyPI tarball doesn't contain test images so let's use GitHub

     
···

       24
       26
        
           owner = "jterrace";

     

       25
       27
        
           repo = pname;

     

       26
       28
        
           rev = "v${version}";

     

       27
       27
       -
           sha256 = "sha256-VvxQTvDTDms6Ccyclbf9P0HEQksl5atPPzHuH8yXTmc=";

     

       29
       29
       +
           sha256 = "sha256-LDNIugQeRqNsAZ5ZxS/NxHokEAwefpfRutTRpR0IcXk=";

     

       28
       30
        
         };

     

       29
       31
        
       

     

       30
       32
        
         patches = [

     

       31
       31
       -
           # "Replace Image.ANTIALIAS with Image.LANCZOS"

     

       32
       32
       -
           # Image.ANTIALIAS has been removed in Pillow 10.0.0,

     

       33
       33
       -
           # the version currently in nixpkgs,

     

       34
       34
       -
           # and Image.LANCZOS is a drop-in since Pillow 2.7.0.

     

       35
       35
       -
           # https://github.com/jterrace/pyssim/pull/45

     

       33
       33
       +
           # "Use PyWavelets for continuous wavelet transform"; signal.cwt was removed and broke the build

     

       36
       34
        
           (fetchpatch {

     

       37
       37
       -
             url = "https://github.com/jterrace/pyssim/commit/db4296c12ca9c027eb9cd61b52195a78dfcc6711.patch";

     

       38
       38
       -
             hash = "sha256-wNp47EFtjXv6jIFX25IErXg83ksmGRNFKNeMFS+tP6s=";

     

       35
       35
       +
             url = "https://github.com/jterrace/pyssim/commit/64a58687f261eb397e9c22609b5d48497ef02762.patch?full_index=1";

     

       36
       36
       +
             hash = "sha256-u6okuWZgGcYlf/SW0QLrAv0IYuJi7D8RHHEr8DeXKcw=";

     

       39
       37
        
           })

     

       40
       38
        
         ];

     

       41
       39
        
       

     

       42
       42
       -
         # Tests are copied from .travis.yml

     

       40
       40
       +
         # Tests are copied from .github/workflows/python-package.yml

     

       43
       41
        
         checkPhase = ''

     

       44
       42
        
           $out/bin/pyssim test-images/test1-1.png test-images/test1-1.png | grep 1

     

       45
       43
        
           $out/bin/pyssim test-images/test1-1.png test-images/test1-2.png | grep 0.998

     
···

       48
       46
        
           $out/bin/pyssim --cw --width 128 --height 128 test-images/test3-orig.jpg test-images/test3-rot.jpg | grep 0.938

     

       49
       47
        
         '';

     

       50
       48
        
       

     

       51
       51
       -
         meta = with lib; {

     

       49
       49
       +
         meta = {

     

       52
       50
        
           description = "Module for computing Structured Similarity Image Metric (SSIM) in Python";

     

       53
       51
        
           mainProgram = "pyssim";

     

       54
       52
        
           homepage = "https://github.com/jterrace/pyssim";

     

       55
       55
       -
           license = licenses.mit;

     

       56
       56
       -
           maintainers = with maintainers; [ jluttine ];

     

       53
       53
       +
           license = lib.licenses.mit;

     

       54
       54
       +
           maintainers = with lib.maintainers; [ jluttine ];

     

       57
       55
        
         };

     

       58
       56
        
       }

+3 -7

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

···

       32
       32
        
       

     

       33
       33
        
       buildPythonPackage rec {

     

       34
       34
        
         pname = "pytensor";

     

       35
       35
       -
         version = "2.28.3";

     

       35
       35
       +
         version = "2.30.2";

     

       36
       36
        
         pyproject = true;

     

       37
       37
        
       

     

       38
       38
        
         src = fetchFromGitHub {

     

       39
       39
        
           owner = "pymc-devs";

     

       40
       40
        
           repo = "pytensor";

     

       41
       41
        
           tag = "rel-${version}";

     

       42
       42
       -
           hash = "sha256-MtY0JbziboJNHKe8wXaPtOWgFnpv8yQZeg6hNirnSEI=";

     

       42
       42
       +
           hash = "sha256-l9/N6DFR8qTF4BiH+g6H32r0FkpL9Pjtn/xkiFYYJhU=";

     

       43
       43
        
         };

     

       44
       44
       -
       

     

       45
       45
       -
         pythonRelaxDeps = [

     

       46
       46
       -
           "scipy"

     

       47
       47
       -
         ];

     

       48
       44
        
       

     

       49
       45
        
         build-system = [

     

       50
       46
        
           cython

     
···

       163
       159
        
           description = "Python library to define, optimize, and efficiently evaluate mathematical expressions involving multi-dimensional arrays";

     

       164
       160
        
           mainProgram = "pytensor-cache";

     

       165
       161
        
           homepage = "https://github.com/pymc-devs/pytensor";

     

       166
       166
       -
           changelog = "https://github.com/pymc-devs/pytensor/releases/tag/red-${version}";

     

       162
       162
       +
           changelog = "https://github.com/pymc-devs/pytensor/releases/tag/rel-${version}";

     

       167
       163
        
           license = lib.licenses.bsd3;

     

       168
       164
        
           maintainers = with lib.maintainers; [

     

       169
       165
        
             bcdarwin

+3 -3

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

···

       11
       11
        
       

     

       12
       12
        
       buildPythonPackage rec {

     

       13
       13
        
         pname = "resend";

     

       14
       14
       -
         version = "2.6.0";

     

       14
       14
       +
         version = "2.7.0";

     

       15
       15
        
         pyproject = true;

     

       16
       16
        
       

     

       17
       17
        
         disabled = pythonOlder "3.7";

     
···

       20
       20
        
           owner = "resend";

     

       21
       21
        
           repo = "resend-python";

     

       22
       22
        
           tag = "v${version}";

     

       23
       23
       -
           hash = "sha256-Sxe1TS/MahzKObPpo4+Iq+jbIuw4H1NJ3oU74MXZByQ=";

     

       23
       23
       +
           hash = "sha256-Uo8Shryw365l1970R0VpvGPAJOTxuJy6ZjIE2pcZkGs=";

     

       24
       24
        
         };

     

       25
       25
        
       

     

       26
       26
        
         build-system = [ setuptools ];

     
···

       37
       37
        
         meta = with lib; {

     

       38
       38
        
           description = "SDK for Resend";

     

       39
       39
        
           homepage = "https://github.com/resend/resend-python";

     

       40
       40
       -
           changelog = "https://github.com/resend/resend-python/releases/tag/v${version}";

     

       40
       40
       +
           changelog = "https://github.com/resend/resend-python/releases/tag/${src.tag}";

     

       41
       41
        
           license = licenses.mit;

     

       42
       42
        
           maintainers = with maintainers; [ fab ];

     

       43
       43
        
         };

-2

pkgs/development/python-modules/wgpu-py/default.nix

···

       34
       34
        
         # passthru

     

       35
       35
        
         wgpu-py,

     

       36
       36
        
         testers,

     

       37
       37
       -
         nix-update-script,

     

       38
       37
        
       }:

     

       39
       38
        
       buildPythonPackage rec {

     

       40
       39
        
         pname = "wgpu-py";

     
···

       107
       106
        
         doCheck = false;

     

       108
       107
        
       

     

       109
       108
        
         passthru = {

     

       110
       110
       -
           updateScript = nix-update-script { rev-prefix = "v"; };

     

       111
       109
        
           tests =

     

       112
       110
        
             {

     

       113
       111
        
               version = testers.testVersion {

pkgs/kde/plasma/plasma-workspace/default.nix

···

       17
       17
        
         qttools,

     

       18
       18
        
         qqc2-breeze-style,

     

       19
       19
        
         gpsd,

     

       20
       20
       +
         fetchpatch,

     

       20
       21
        
       }:

     

       21
       22
        
       mkKdeDerivation {

     

       22
       23
        
         pname = "plasma-workspace";

     
···

       31
       32
        
             xrdb = lib.getExe xorg.xrdb;

     

       32
       33
        
             # @QtBinariesDir@ only appears in the *removed* lines of the diff

     

       33
       34
        
             QtBinariesDir = null;

     

       35
       35
       +
           })

     

       36
       36
       +
       

     

       37
       37
       +
           # Backport patch recommended by upstream

     

       38
       38
       +
           # FIXME: remove in 6.3.5

     

       39
       39
       +
           (fetchpatch {

     

       40
       40
       +
             url = "https://invent.kde.org/plasma/plasma-workspace/-/commit/47d502353720004fa2d0e7b0065994b75b3e0ded.patch";

     

       41
       41
       +
             hash = "sha256-wt0ZIF4zcEOmP0o4ZcjBYxVjr2hVUlOKVJ8SMNSYt68=";

     

       34
       42
        
           })

     

       35
       43
        
         ];

     

       36
       44

-9

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

···

       17
       17
        
             inherit (versionInfo.scx) hash;

     

       18
       18
        
           };

     

       19
       19
        
       

     

       20
       20
       -
           patches = [

     

       21
       21
       -
             # Remove after new release

     

       22
       22
       -
             (fetchpatch2 {

     

       23
       23
       -
               name = "fix-builds-on-debug-fs-kernels";

     

       24
       24
       -
               url = "https://github.com/sched-ext/scx/commit/3c09e8c8c62efd701107f4c2071211db02341d62.patch?full_index=1";

     

       25
       25
       -
               hash = "sha256-jLMlCKBYQKS6sf5pZy5z19iSmX9bu9rlXHmGVaxTOho=";

     

       26
       26
       -
             })

     

       27
       27
       -
           ];

     

       28
       28
       -
       

     

       29
       20
        
           meta = {

     

       30
       21
        
             homepage = "https://github.com/sched-ext/scx";

     

       31
       22
        
             changelog = "https://github.com/sched-ext/scx/releases/tag/v${versionInfo.scx.version}";

+1 -1

pkgs/os-specific/linux/scx/scx_cscheds.nix

···

       26
       26
        
       in

     

       27
       27
        
       llvmPackages.stdenv.mkDerivation (finalAttrs: {

     

       28
       28
        
         pname = "scx_cscheds";

     

       29
       29
       -
         inherit (scx-common) version src patches;

     

       29
       29
       +
         inherit (scx-common) version src;

     

       30
       30
        
       

     

       31
       31
        
         # scx needs specific commits of bpftool and libbpf

     

       32
       32
        
         # can be found in meson.build of scx src

+1 -1

pkgs/os-specific/linux/scx/scx_rustscheds.nix

···

       11
       11
        
       }:

     

       12
       12
        
       rustPlatform.buildRustPackage {

     

       13
       13
        
         pname = "scx_rustscheds";

     

       14
       14
       -
         inherit (scx-common) version src patches;

     

       14
       14
       +
         inherit (scx-common) version src;

     

       15
       15
        
       

     

       16
       16
        
         useFetchCargoVendor = true;

     

       17
       17
        
         inherit (scx-common.versionInfo.scx) cargoHash;

+3 -3

pkgs/os-specific/linux/scx/version.json

···

       1
       1
        
       {

     

       2
       2
        
         "scx": {

     

       3
       3
       -
           "version": "1.0.10",

     

       4
       4
       -
           "hash": "sha256-IJn3MAPEwxImHUfHV7zPNlAlHXvzOkH0S7eJDNnupf0=",

     

       5
       5
       -
           "cargoHash": "sha256-d0TvLhBaDgqi4/dtVgL+UOn78uaqSpdFxm4kBdVyCR4="

     

       3
       3
       +
           "version": "1.0.11",

     

       4
       4
       +
           "hash": "sha256-Lj+YH+pWcdbGvpk6PAgat279cXOGkm0SZ5+wdK+2u9Q=",

     

       5
       5
       +
           "cargoHash": "sha256-sDrkUiZpX04A6a4ltFFZo6qtUgUgZ0ydml4mfKYYu3g="

     

       6
       6
        
         },

     

       7
       7
        
         "bpftool": {

     

       8
       8
        
           "rev": "183e7010387d1fc9f08051426e9a9fbd5f8d409e",

+5 -3

pkgs/tools/networking/vpn-slice/default.nix

···

       3
       3
        
         stdenv,

     

       4
       4
        
         buildPythonApplication,

     

       5
       5
        
         nix-update-script,

     

       6
       6
       -
         python3Packages,

     

       7
       6
        
         fetchFromGitHub,

     

       7
       7
       +
         dnspython,

     

       8
       8
        
         iproute2,

     

       9
       9
        
         iptables,

     

       10
       10
       +
         setproctitle,

     

       11
       11
       +
         setuptools,

     

       10
       12
        
         unixtools,

     

       11
       13
        
       }:

     

       12
       14
        
       

     
···

       33
       35
        
               --replace-fail "'/sbin/iptables'" "'${iptables}/bin/iptables'"

     

       34
       36
        
           '';

     

       35
       37
        
       

     

       36
       36
       -
         build-system = with python3Packages; [

     

       38
       38
       +
         build-system = [

     

       37
       39
        
           setuptools

     

       38
       40
        
         ];

     

       39
       41
        
       

     

       40
       40
       -
         dependencies = with python3Packages; [

     

       42
       42
       +
         dependencies = [

     

       41
       43
        
           setuptools # can be removed with next package update, upstream no longer has a dependency on distutils

     

       42
       44
        
           setproctitle

     

       43
       45
        
           dnspython

+5 -5

pkgs/tools/security/bitwarden-directory-connector/default.nix

···

       7
       7
        
         python3,

     

       8
       8
        
         pkg-config,

     

       9
       9
        
         libsecret,

     

       10
       10
       -
         nodejs_18,

     

       10
       10
       +
         nodejs_22,

     

       11
       11
        
       }:

     

       12
       12
        
       

     

       13
       13
        
       let

     
···

       19
       19
        
           }:

     

       20
       20
        
           buildNpmPackage rec {

     

       21
       21
        
             pname = name;

     

       22
       22
       -
             version = "2025.1.0";

     

       23
       23
       -
             nodejs = nodejs_18;

     

       22
       22
       +
             version = "2025.3.0";

     

       23
       23
       +
             nodejs = nodejs_22;

     

       24
       24
        
       

     

       25
       25
        
             src = fetchFromGitHub {

     

       26
       26
        
               owner = "bitwarden";

     

       27
       27
        
               repo = "directory-connector";

     

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

     

       29
       29
       -
               hash = "sha256-4Bt+E0lkmRXY4yIq6DwCyggcu7/8QtaYE9QHNTUhM+8=";

     

       29
       29
       +
               hash = "sha256-8EY+bU7i3fdUBQYsykUzgOIWS5VAJlmRYW8fsp0xfnY=";

     

       30
       30
        
             };

     

       31
       31
        
       

     

       32
       32
        
             postPatch = ''

     
···

       38
       38
        
                 --replace-fail "AppImage" "dir"

     

       39
       39
        
             '';

     

       40
       40
        
       

     

       41
       41
       -
             npmDepsHash = "sha256-vvVZIfRZw5C4pLUkNHS+kgD7MzoImvsf8CGxdH2xXOs=";

     

       41
       41
       +
             npmDepsHash = "sha256-2McM5o6CxEu8YcFl4ey9cirfJYYIY3kLkuyLL020E+A=";

     

       42
       42
        
       

     

       43
       43
        
             env.ELECTRON_SKIP_BINARY_DOWNLOAD = "1";

     

       44
       44

+2 -1

pkgs/top-level/all-packages.nix

···

       4496
       4496
        
       

     

       4497
       4497
        
         netcat = libressl.nc.overrideAttrs (old: {

     

       4498
       4498
        
           meta = old.meta // {

     

       4499
       4499
       +
             description = "Utility which reads and writes data across network connections — LibreSSL implementation";

     

       4499
       4500
        
             mainProgram = "nc";

     

       4500
       4501
        
           };

     

       4501
       4502
        
         });

     
···

       15720
       15721
        
       

     

       15721
       15722
        
         openscad = libsForQt5.callPackage ../applications/graphics/openscad { };

     

       15722
       15723
        
       

     

       15723
       15723
       -
         opentimestamps-client = python3Packages.callPackage ../tools/misc/opentimestamps-client { };

     

       15724
       15724
       +
         opentimestamps-client = callPackage ../tools/misc/opentimestamps-client { };

     

       15724
       15725
        
       

     

       15725
       15726
        
         opentoonz = libsForQt5.callPackage ../applications/graphics/opentoonz { };

     

       15726
       15727

pkgs/top-level/python-packages.nix

···

       12877
       12877
        
       

     

       12878
       12878
        
         pypoolstation = callPackage ../development/python-modules/pypoolstation { };

     

       12879
       12879
        
       

     

       12880
       12880
       +
         pyporscheconnectapi = callPackage ../development/python-modules/pyporscheconnectapi { };

     

       12881
       12881
       +
       

     

       12880
       12882
        
         pyppeteer = callPackage ../development/python-modules/pyppeteer { };

     

       12881
       12883
        
       

     

       12882
       12884
        
         pyppmd = callPackage ../development/python-modules/pyppmd { };