commit 122355be994486ec9dbb4e1e87c9206bec11b521 · pyrox.dev/nixpkgs

+12 -9

doc/build-helpers/special/checkpoint-build.section.md

···

       2
       2
        
       

     

       3
       3
        
       `pkgs.checkpointBuildTools` provides a way to build derivations incrementally. It consists of two functions to make checkpoint builds using Nix possible.

     

       4
       4
        
       

     

       5
       5
       -
       For hermeticity, Nix derivations do not allow any state to carry over between builds, making a transparent incremental build within a derivation impossible.

     

       5
       5
       +
       For hermeticity, Nix derivations do not allow any state to be carried over between builds, making a transparent incremental build within a derivation impossible.

     

       6
       6
        
       

     

       7
       7
        
       However, we can tell Nix explicitly what the previous build state was, by representing that previous state as a derivation output. This allows the passed build state to be used for an incremental build.

     

       8
       8
        
       

     

       9
       9
        
       To change a normal derivation to a checkpoint based build, these steps must be taken:

     

       10
       10
       -
         - apply `prepareCheckpointBuild` on the desired derivation

     

       11
       11
       -
           e.g.:

     

       10
       10
       +
         - apply `prepareCheckpointBuild` on the desired derivation, e.g.

     

       12
       11
        
       ```nix

     

       13
       12
        
       checkpointArtifacts = (pkgs.checkpointBuildTools.prepareCheckpointBuild pkgs.virtualbox);

     

       14
       13
        
       ```

     

       15
       15
       -
         - change something you want in the sources of the package. (e.g. using a source override)

     

       14
       14
       +
         - change something you want in the sources of the package, e.g. use a source override:

     

       16
       15
        
       ```nix

     

       17
       16
        
       changedVBox = pkgs.virtualbox.overrideAttrs (old: {

     

       18
       17
        
         src = path/to/vbox/sources;

     

       19
       19
       -
       }

     

       18
       18
       +
       });

     

       20
       19
        
       ```

     

       21
       21
       -
         - use `mkCheckpointedBuild changedVBox buildOutput`

     

       20
       20
       +
         - use `mkCheckpointBuild changedVBox checkpointArtifacts`

     

       22
       21
        
         - enjoy shorter build times

     

       23
       22
        
       

     

       24
       23
        
       ## Example {#sec-checkpoint-build-example}

     

       25
       24
        
       ```nix

     

       26
       26
       -
       { pkgs ? import <nixpkgs> {} }: with (pkgs) checkpointBuildTools;

     

       25
       25
       +
       { pkgs ? import <nixpkgs> {} }:

     

       27
       26
        
       let

     

       28
       28
       -
         helloCheckpoint = checkpointBuildTools.prepareCheckpointBuild pkgs.hello;

     

       27
       27
       +
         inherit (pkgs.checkpointBuildTools)

     

       28
       28
       +
           prepareCheckpointBuild

     

       29
       29
       +
           mkCheckpointBuild

     

       30
       30
       +
           ;

     

       31
       31
       +
         helloCheckpoint = prepareCheckpointBuild pkgs.hello;

     

       29
       32
        
         changedHello = pkgs.hello.overrideAttrs (_: {

     

       30
       33
        
           doCheck = false;

     

       31
       34
        
           patchPhase = ''

     

       32
       35
        
             sed -i 's/Hello, world!/Hello, Nix!/g' src/hello.c

     

       33
       36
        
           '';

     

       34
       37
        
         });

     

       35
       35
       -
       in checkpointBuildTools.mkCheckpointBuild changedHello helloCheckpoint

     

       38
       38
       +
       in mkCheckpointBuild changedHello helloCheckpoint

     

       36
       39
        
       ```

+6

maintainers/maintainer-list.nix

···

       3864
       3864
        
           githubId = 6821729;

     

       3865
       3865
        
           github = "criyle";

     

       3866
       3866
        
         };

     

       3867
       3867
       +
         crschnick = {

     

       3868
       3868
       +
           email = "crschnick@xpipe.io";

     

       3869
       3869
       +
           name = "Christopher Schnick";

     

       3870
       3870
       +
           github = "crschnick";

     

       3871
       3871
       +
           githubId = 72509152;

     

       3872
       3872
       +
         };

     

       3867
       3873
        
         CRTified = {

     

       3868
       3874
        
           email = "carl.schneider+nixos@rub.de";

     

       3869
       3875
        
           matrix = "@schnecfk:ruhr-uni-bochum.de";

+1

nixos/modules/module-list.nix

···

       834
       834
        
         ./services/monitoring/riemann.nix

     

       835
       835
        
         ./services/monitoring/scollector.nix

     

       836
       836
        
         ./services/monitoring/smartd.nix

     

       837
       837
       +
         ./services/monitoring/snmpd.nix

     

       837
       838
        
         ./services/monitoring/statsd.nix

     

       838
       839
        
         ./services/monitoring/sysstat.nix

     

       839
       840
        
         ./services/monitoring/teamviewer.nix

+83

nixos/modules/services/monitoring/snmpd.nix

···

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

     

       2
       2
       +
       

     

       3
       3
       +
       let

     

       4
       4
       +
         cfg = config.services.snmpd;

     

       5
       5
       +
         configFile = if cfg.configText != "" then

     

       6
       6
       +
           pkgs.writeText "snmpd.cfg" ''

     

       7
       7
       +
             ${cfg.configText}

     

       8
       8
       +
           '' else null;

     

       9
       9
       +
       in {

     

       10
       10
       +
         options.services.snmpd = {

     

       11
       11
       +
           enable = lib.mkEnableOption "snmpd";

     

       12
       12
       +
       

     

       13
       13
       +
           package = lib.mkPackageOption pkgs "net-snmp" {};

     

       14
       14
       +
       

     

       15
       15
       +
           listenAddress = lib.mkOption {

     

       16
       16
       +
             type = lib.types.str;

     

       17
       17
       +
             default = "0.0.0.0";

     

       18
       18
       +
             description = lib.mdDoc ''

     

       19
       19
       +
               The address to listen on for SNMP and AgentX messages.

     

       20
       20
       +
             '';

     

       21
       21
       +
             example = "127.0.0.1";

     

       22
       22
       +
           };

     

       23
       23
       +
       

     

       24
       24
       +
           port = lib.mkOption {

     

       25
       25
       +
             type = lib.types.port;

     

       26
       26
       +
             default = 161;

     

       27
       27
       +
             description = lib.mdDoc ''

     

       28
       28
       +
               The port to listen on for SNMP and AgentX messages.

     

       29
       29
       +
             '';

     

       30
       30
       +
           };

     

       31
       31
       +
       

     

       32
       32
       +
           openFirewall = lib.mkOption {

     

       33
       33
       +
             type = lib.types.bool;

     

       34
       34
       +
             default = false;

     

       35
       35
       +
             description = lib.mdDoc ''

     

       36
       36
       +
               Open port in firewall for snmpd.

     

       37
       37
       +
             '';

     

       38
       38
       +
           };

     

       39
       39
       +
       

     

       40
       40
       +
           configText = lib.mkOption {

     

       41
       41
       +
             type = lib.types.lines;

     

       42
       42
       +
             default = "";

     

       43
       43
       +
             description = lib.mdDoc ''

     

       44
       44
       +
               The contents of the snmpd.conf. If the {option}`configFile` option

     

       45
       45
       +
               is set, this value will be ignored.

     

       46
       46
       +
       

     

       47
       47
       +
               Note that the contents of this option will be added to the Nix

     

       48
       48
       +
               store as world-readable plain text, {option}`configFile` can be used in

     

       49
       49
       +
               addition to a secret management tool to protect sensitive data.

     

       50
       50
       +
             '';

     

       51
       51
       +
           };

     

       52
       52
       +
       

     

       53
       53
       +
           configFile = lib.mkOption {

     

       54
       54
       +
             type = lib.types.path;

     

       55
       55
       +
             default = configFile;

     

       56
       56
       +
             defaultText = lib.literalMD "The value of {option}`configText`.";

     

       57
       57
       +
             description = lib.mdDoc ''

     

       58
       58
       +
               Path to the snmpd.conf file. By default, if {option}`configText` is set,

     

       59
       59
       +
               a config file will be automatically generated.

     

       60
       60
       +
             '';

     

       61
       61
       +
           };

     

       62
       62
       +
       

     

       63
       63
       +
         };

     

       64
       64
       +
       

     

       65
       65
       +
         config = lib.mkIf cfg.enable {

     

       66
       66
       +
           systemd.services."snmpd" = {

     

       67
       67
       +
             description = "Simple Network Management Protocol (SNMP) daemon.";

     

       68
       68
       +
             after = [ "network.target" ];

     

       69
       69
       +
             wantedBy = [ "multi-user.target" ];

     

       70
       70
       +
             serviceConfig = {

     

       71
       71
       +
               Type = "simple";

     

       72
       72
       +
               ExecStart = "${lib.getExe' cfg.package "snmpd"} -f -Lo -c ${cfg.configFile} ${cfg.listenAddress}:${toString cfg.port}";

     

       73
       73
       +
             };

     

       74
       74
       +
           };

     

       75
       75
       +
       

     

       76
       76
       +
           networking.firewall.allowedUDPPorts = lib.mkIf cfg.openFirewall [

     

       77
       77
       +
             cfg.port

     

       78
       78
       +
           ];

     

       79
       79
       +
         };

     

       80
       80
       +
       

     

       81
       81
       +
         meta.maintainers = [ lib.maintainers.eliandoran ];

     

       82
       82
       +
       

     

       83
       83
       +
       }

+4 -1

nixos/modules/services/printing/cupsd.nix

···

       4
       4
        
       

     

       5
       5
        
       let

     

       6
       6
        
       

     

       7
       7
       -
         inherit (pkgs) cups cups-pk-helper cups-filters xdg-utils;

     

       7
       7
       +
         inherit (pkgs) cups-pk-helper cups-filters xdg-utils;

     

       8
       8
        
       

     

       9
       9
        
         cfg = config.services.printing;

     

       10
       10
       +
         cups = cfg.package;

     

       10
       11
        
       

     

       11
       12
        
         avahiEnabled = config.services.avahi.enable;

     

       12
       13
        
         polkitEnabled = config.security.polkit.enable;

     
···

       139
       140
        
                 Whether to enable printing support through the CUPS daemon.

     

       140
       141
        
               '';

     

       141
       142
        
             };

     

       143
       143
       +
       

     

       144
       144
       +
             package = lib.mkPackageOption pkgs "cups" {};

     

       142
       145
        
       

     

       143
       146
        
             stateless = mkOption {

     

       144
       147
        
               type = types.bool;

+5 -15

nixos/modules/virtualisation/lxd.nix

···

       33
       33
        
               '';

     

       34
       34
        
             };

     

       35
       35
        
       

     

       36
       36
       -
             package = lib.mkOption {

     

       37
       37
       -
               type = lib.types.package;

     

       38
       38
       -
               default = pkgs.lxd;

     

       39
       39
       -
               defaultText = lib.literalExpression "pkgs.lxd";

     

       40
       40
       -
               description = lib.mdDoc ''

     

       41
       41
       -
                 The LXD package to use.

     

       42
       42
       -
               '';

     

       43
       43
       -
             };

     

       36
       36
       +
             package = lib.mkPackageOption pkgs "lxd" { };

     

       44
       37
        
       

     

       45
       45
       -
             lxcPackage = lib.mkOption {

     

       46
       46
       -
               type = lib.types.package;

     

       47
       47
       -
               default = pkgs.lxc;

     

       48
       48
       -
               defaultText = lib.literalExpression "pkgs.lxc";

     

       49
       49
       -
               description = lib.mdDoc ''

     

       50
       50
       -
                 The LXC package to use with LXD (required for AppArmor profiles).

     

       38
       38
       +
             lxcPackage = lib.mkPackageOption pkgs "lxc" {

     

       39
       39
       +
               extraDescription = ''

     

       40
       40
       +
                 Required for AppArmor profiles.

     

       51
       41
        
               '';

     

       52
       42
        
             };

     

       53
       43
        
       

     
···

       149
       139
        
             ui = {

     

       150
       140
        
               enable = lib.mkEnableOption (lib.mdDoc "(experimental) LXD UI");

     

       151
       141
        
       

     

       152
       152
       -
               package = lib.mkPackageOption pkgs.lxd-unwrapped "ui" { };

     

       142
       142
       +
               package = lib.mkPackageOption pkgs [ "lxd-unwrapped" "ui" ] { };

     

       153
       143
        
             };

     

       154
       144
        
           };

     

       155
       145
        
         };

+1

nixos/tests/all-tests.nix

···

       773
       773
        
         sing-box = handleTest ./sing-box.nix {};

     

       774
       774
        
         slimserver = handleTest ./slimserver.nix {};

     

       775
       775
        
         slurm = handleTest ./slurm.nix {};

     

       776
       776
       +
         snmpd = handleTest ./snmpd.nix {};

     

       776
       777
        
         smokeping = handleTest ./smokeping.nix {};

     

       777
       778
        
         snapcast = handleTest ./snapcast.nix {};

     

       778
       779
        
         snapper = handleTest ./snapper.nix {};

+23

nixos/tests/snmpd.nix

···

       1
       1
       +
       import ./make-test-python.nix ({ pkgs, lib, ... }: {

     

       2
       2
       +
         name = "snmpd";

     

       3
       3
       +
       

     

       4
       4
       +
         nodes.snmpd = {

     

       5
       5
       +
           environment.systemPackages = with pkgs; [

     

       6
       6
       +
             net-snmp

     

       7
       7
       +
           ];

     

       8
       8
       +
       

     

       9
       9
       +
           services.snmpd = {

     

       10
       10
       +
             enable = true;

     

       11
       11
       +
             configText = ''

     

       12
       12
       +
               rocommunity public

     

       13
       13
       +
             '';

     

       14
       14
       +
           };

     

       15
       15
       +
         };

     

       16
       16
       +
       

     

       17
       17
       +
         testScript = ''

     

       18
       18
       +
           start_all();

     

       19
       19
       +
           machine.wait_for_unit("snmpd.service")

     

       20
       20
       +
           machine.succeed("snmpwalk -v 2c -c public localhost | grep SNMPv2-MIB::sysName.0");

     

       21
       21
       +
         '';

     

       22
       22
       +
       

     

       23
       23
       +
       })

+3 -3

pkgs/applications/misc/clipcat/default.nix

···

       7
       7
        
       

     

       8
       8
        
       rustPlatform.buildRustPackage rec {

     

       9
       9
        
         pname = "clipcat";

     

       10
       10
       -
         version = "0.16.0";

     

       10
       10
       +
         version = "0.16.1";

     

       11
       11
        
       

     

       12
       12
        
         src = fetchFromGitHub {

     

       13
       13
        
           owner = "xrelkd";

     

       14
       14
        
           repo = pname;

     

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

     

       16
       16
       -
           hash = "sha256-9BilasXc/3FFPcKAgPvc0hIHP7NbOqRD8ZwIMRc/Y3M=";

     

       16
       16
       +
           hash = "sha256-SqA8UjKTBtkE1IkWGeshI8KBHr86V9r/+YvFZNJ6Oq8=";

     

       17
       17
        
         };

     

       18
       18
        
       

     

       19
       19
       -
         cargoHash = "sha256-zkeKhi0DiYqA5+KiU77ZJXRyhLUKVDmHvF7TG1URzo4=";

     

       19
       19
       +
         cargoHash = "sha256-KU3kXqy9zL7GQdSsCNW7jcsxdTuRXjJyDtBpmgoXi6E=";

     

       20
       20
        
       

     

       21
       21
        
         nativeBuildInputs = [

     

       22
       22
        
           protobuf

+2 -2

pkgs/applications/misc/openlp/lib.nix

···

       5
       5
        
       # python deps

     

       6
       6
        
       , python, buildPythonPackage

     

       7
       7
        
       , alembic, beautifulsoup4, chardet, lxml, mako, pyenchant

     

       8
       8
       -
       , pyqt5_with_qtwebkit, pyxdg, sip_4, sqlalchemy, sqlalchemy-migrate

     

       8
       8
       +
       , pyqt5-webkit, pyxdg, sip_4, sqlalchemy, sqlalchemy-migrate

     

       9
       9
        
       }:

     

       10
       10
        
       

     

       11
       11
        
       buildPythonPackage rec {

     
···

       39
       39
        
           lxml

     

       40
       40
        
           mako

     

       41
       41
        
           pyenchant

     

       42
       42
       -
           pyqt5_with_qtwebkit

     

       42
       42
       +
           pyqt5-webkit

     

       43
       43
        
           pyxdg

     

       44
       44
        
           sip_4

     

       45
       45
        
           sqlalchemy

+3 -3

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

···

       2
       2
        
       

     

       3
       3
        
       buildGoModule rec {

     

       4
       4
        
         pname = "stern";

     

       5
       5
       -
         version = "1.27.0";

     

       5
       5
       +
         version = "1.28.0";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "stern";

     

       9
       9
        
           repo = "stern";

     

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

     

       11
       11
       -
           sha256 = "sha256-W8jGUs63R6QpwuTgzK5yVLhKGXypvKOyCWHT2xdb6eM=";

     

       11
       11
       +
           sha256 = "sha256-Lx5f2dqjdhgMXky1Pv2ik9i56ugsQmZK/ag4veC9Dac=";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
       -
         vendorHash = "sha256-LLVd9WB8ixH78CHYe0sS4sCDCD+6SQ7PxWr2MHiAOxI=";

     

       14
       14
       +
         vendorHash = "sha256-6jI/I7Nw/vJwKNvgH/35uHYu51SBX+WFH5s0WKfCqBo=";

     

       15
       15
        
       

     

       16
       16
        
         subPackages = [ "." ];

     

       17
       17

+1 -1

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

···

       11
       11
        
           sha256 = "1ffdy74igll74fwpmnn3brvcxbk4iianqscdzz18sx1pfqpw16cl";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
       -
         propagatedBuildInputs = with python3Packages; [ pyqt5_with_qtwebkit dbus-python jsmin ];

     

       14
       14
       +
         propagatedBuildInputs = with python3Packages; [ pyqt5-webkit dbus-python jsmin ];

     

       15
       15
        
       

     

       16
       16
        
         meta = with lib; {

     

       17
       17
        
           description = "Non-official desktop client for Slack";

+3 -3

pkgs/applications/networking/sync/rclone/default.nix

···

       6
       6
        
       

     

       7
       7
        
       buildGoModule rec {

     

       8
       8
        
         pname = "rclone";

     

       9
       9
       -
         version = "1.65.0";

     

       9
       9
       +
         version = "1.65.1";

     

       10
       10
        
       

     

       11
       11
        
         src = fetchFromGitHub {

     

       12
       12
        
           owner = pname;

     

       13
       13
        
           repo = pname;

     

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

     

       15
       15
       -
           hash = "sha256-hlkX8JrBz/hFwQj0xCZfuBt2t3CP3Xa1JkNDH0zomxg=";

     

       15
       15
       +
           hash = "sha256-wRksCRQR6JZjYtXgq3iARCoYck76O17Kd2Ht1XpA9KE=";

     

       16
       16
        
         };

     

       17
       17
        
       

     

       18
       18
       -
         vendorHash = "sha256-qKRIT2HqNDpEtZBNHZMXp4Yhh5fCkQSTPU5MQ7FmCHI=";

     

       18
       18
       +
         vendorHash = "sha256-kWaMo6ALieuwf53H05UdoI7xtH1LAnsD6Ak9bJTa6jc=";

     

       19
       19
        
       

     

       20
       20
        
         subPackages = [ "." ];

     

       21
       21

+132

pkgs/applications/networking/xpipe/default.nix

···

       1
       1
       +
       { stdenvNoCC

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchzip

     

       4
       4
       +
       , makeDesktopItem

     

       5
       5
       +
       , autoPatchelfHook

     

       6
       6
       +
       , zlib

     

       7
       7
       +
       , fontconfig

     

       8
       8
       +
       , udev

     

       9
       9
       +
       , gtk3

     

       10
       10
       +
       , freetype

     

       11
       11
       +
       , alsa-lib

     

       12
       12
       +
       , makeShellWrapper

     

       13
       13
       +
       , libX11

     

       14
       14
       +
       , libXext

     

       15
       15
       +
       , libXdamage

     

       16
       16
       +
       , libXfixes

     

       17
       17
       +
       , libxcb

     

       18
       18
       +
       , libXcomposite

     

       19
       19
       +
       , libXcursor

     

       20
       20
       +
       , libXi

     

       21
       21
       +
       , libXrender

     

       22
       22
       +
       , libXtst

     

       23
       23
       +
       , libXxf86vm

     

       24
       24
       +
       }:

     

       25
       25
       +
       

     

       26
       26
       +
       let

     

       27
       27
       +
         inherit (stdenvNoCC.hostPlatform) system;

     

       28
       28
       +
         throwSystem = throw "Unsupported system: ${system}";

     

       29
       29
       +
       

     

       30
       30
       +
         arch = {

     

       31
       31
       +
           x86_64-linux = "x86_64";

     

       32
       32
       +
           aarch64-linux = "arm64";

     

       33
       33
       +
         }.${system} or throwSystem;

     

       34
       34
       +
       

     

       35
       35
       +
         hash = {

     

       36
       36
       +
           x86_64-linux = "sha256-/cumOKaWPdAruMLZP2GMUdocIhsbo59dc4Q3ngc/JOc=";

     

       37
       37
       +
           aarch64-linux = "sha256-xMV+9etnuFwRGIHdaXNViKd4FMOuVtugGDS1xyMwEnM=";

     

       38
       38
       +
         }.${system} or throwSystem;

     

       39
       39
       +
       

     

       40
       40
       +
         displayname = "XPipe";

     

       41
       41
       +
       

     

       42
       42
       +
       in stdenvNoCC.mkDerivation rec {

     

       43
       43
       +
         pname = "xpipe";

     

       44
       44
       +
         version = "1.7.3";

     

       45
       45
       +
       

     

       46
       46
       +
         src = fetchzip {

     

       47
       47
       +
           url = "https://github.com/xpipe-io/xpipe/releases/download/${version}/xpipe-portable-linux-${arch}.tar.gz";

     

       48
       48
       +
           inherit hash;

     

       49
       49
       +
         };

     

       50
       50
       +
       

     

       51
       51
       +
         nativeBuildInputs = [

     

       52
       52
       +
           autoPatchelfHook

     

       53
       53
       +
           makeShellWrapper

     

       54
       54
       +
         ];

     

       55
       55
       +
       

     

       56
       56
       +
         # Ignore libavformat dependencies as we don't need them

     

       57
       57
       +
         autoPatchelfIgnoreMissingDeps = true;

     

       58
       58
       +
       

     

       59
       59
       +
         buildInputs = [

     

       60
       60
       +
             fontconfig

     

       61
       61
       +
             zlib

     

       62
       62
       +
             udev

     

       63
       63
       +
             freetype

     

       64
       64
       +
             gtk3

     

       65
       65
       +
             alsa-lib

     

       66
       66
       +
             libX11

     

       67
       67
       +
             libX11

     

       68
       68
       +
             libXext

     

       69
       69
       +
             libXdamage

     

       70
       70
       +
             libXfixes

     

       71
       71
       +
             libxcb

     

       72
       72
       +
             libXcomposite

     

       73
       73
       +
             libXcursor

     

       74
       74
       +
             libXi

     

       75
       75
       +
             libXrender

     

       76
       76
       +
             libXtst

     

       77
       77
       +
             libXxf86vm

     

       78
       78
       +
           ];

     

       79
       79
       +
       

     

       80
       80
       +
         desktopItem = makeDesktopItem {

     

       81
       81
       +
           categories = [ "Network" ];

     

       82
       82
       +
           comment = "Your entire server infrastructure at your fingertips";

     

       83
       83
       +
           desktopName = displayname;

     

       84
       84
       +
           exec = "/opt/${pname}/cli/bin/xpipe open %U";

     

       85
       85
       +
           genericName = "Shell connection hub";

     

       86
       86
       +
           icon = "/opt/${pname}/logo.png";

     

       87
       87
       +
           name = displayname;

     

       88
       88
       +
         };

     

       89
       89
       +
       

     

       90
       90
       +
         installPhase = ''

     

       91
       91
       +
           runHook preInstall

     

       92
       92
       +
       

     

       93
       93
       +
           pkg="${pname}"

     

       94
       94
       +
           mkdir -p $out/opt/$pkg

     

       95
       95
       +
           cp -r ./ $out/opt/$pkg

     

       96
       96
       +
       

     

       97
       97
       +
           mkdir -p "$out/bin"

     

       98
       98
       +
           ln -s "$out/opt/$pkg/cli/bin/xpipe" "$out/bin/$pkg"

     

       99
       99
       +
       

     

       100
       100
       +
           mkdir -p "$out/share/applications"

     

       101
       101
       +
           cp -r "${desktopItem}/share/applications/" "$out/share/"

     

       102
       102
       +
       

     

       103
       103
       +
           mkdir -p "$out/etc/bash_completion.d"

     

       104
       104
       +
           ln -s "$out/opt/$pkg/cli/xpipe_completion" "$out/etc/bash_completion.d/$pkg"

     

       105
       105
       +
       

     

       106
       106
       +
           substituteInPlace $out/share/applications/${displayname}.desktop --replace "Exec=" "Exec=$out"

     

       107
       107
       +
           substituteInPlace $out/share/applications/${displayname}.desktop --replace "Icon=" "Icon=$out"

     

       108
       108
       +
       

     

       109
       109
       +
           mv "$out/opt/xpipe/app/bin/xpiped" "$out/opt/xpipe/app/bin/xpiped_raw"

     

       110
       110
       +
           mv "$out/opt/xpipe/app/lib/app/xpiped.cfg" "$out/opt/xpipe/app/lib/app/xpiped_raw.cfg"

     

       111
       111
       +
           mv "$out/opt/xpipe/app/scripts/xpiped_debug.sh" "$out/opt/xpipe/app/scripts/xpiped_debug_raw.sh"

     

       112
       112
       +
       

     

       113
       113
       +
           makeShellWrapper "$out/opt/xpipe/app/bin/xpiped_raw" "$out/opt/xpipe/app/bin/xpiped" \

     

       114
       114
       +
             --prefix LD_LIBRARY_PATH : "${lib.makeLibraryPath [ fontconfig gtk3 udev ]}"

     

       115
       115
       +
           makeShellWrapper "$out/opt/xpipe/app/scripts/xpiped_debug_raw.sh" "$out/opt/xpipe/app/scripts/xpiped_debug.sh" \

     

       116
       116
       +
             --prefix LD_LIBRARY_PATH : "${lib.makeLibraryPath [ fontconfig gtk3 udev ]}"

     

       117
       117
       +
       

     

       118
       118
       +
           runHook postInstall

     

       119
       119
       +
         '';

     

       120
       120
       +
       

     

       121
       121
       +
         meta = with lib; {

     

       122
       122
       +
           description = "A cross-platform shell connection hub and remote file manager";

     

       123
       123
       +
           homepage = "https://github.com/xpipe-io/${pname}";

     

       124
       124
       +
           downloadPage = "https://github.com/xpipe-io/${pname}/releases/latest";

     

       125
       125
       +
           sourceProvenance = with sourceTypes; [ binaryNativeCode ];

     

       126
       126
       +
           changelog = "https://github.com/xpipe-io/${pname}/releases/tag/${version}";

     

       127
       127
       +
           license = [ licenses.asl20 licenses.unfree ];

     

       128
       128
       +
           maintainers = with maintainers; [ crschnick ];

     

       129
       129
       +
           platforms = [ "x86_64-linux" "aarch64-linux" ];

     

       130
       130
       +
           mainProgram = pname;

     

       131
       131
       +
         };

     

       132
       132
       +
       }

+2 -2

pkgs/applications/office/scribus/default.nix

···

       33
       33
        
       stdenv.mkDerivation (finalAttrs: {

     

       34
       34
        
         pname = "scribus";

     

       35
       35
        
       

     

       36
       36
       -
         version = "1.6.0";

     

       36
       36
       +
         version = "1.6.1";

     

       37
       37
        
       

     

       38
       38
        
         src = fetchurl {

     

       39
       39
        
           url = "mirror://sourceforge/scribus/scribus-devel/scribus-${finalAttrs.version}.tar.xz";

     

       40
       40
       -
           hash = "sha256-lLl0kOzhcoaNxPBMeqLulQtBtfL/QoXfN9YV8ETQOOU=";

     

       40
       40
       +
           hash = "sha256-4J3Xjm22HQG5MhEI/t7bzNbsCrNS3Vuv24sEHw73npk=";

     

       41
       41
        
         };

     

       42
       42
        
       

     

       43
       43
        
         nativeBuildInputs = [

+3 -2

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

···

       54
       54
        
       in

     

       55
       55
        
       stdenv.mkDerivation rec {

     

       56
       56
        
         pname = "cp2k";

     

       57
       57
       -
         version = "2023.2";

     

       57
       57
       +
         version = "2024.1";

     

       58
       58
        
       

     

       59
       59
        
         src = fetchFromGitHub {

     

       60
       60
        
           owner = "cp2k";

     

       61
       61
        
           repo = "cp2k";

     

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

     

       63
       63
       -
           hash = "sha256-1TJorIjajWFO7i9vqSBDTAIukBdyvxbr5dargt4QB8M=";

     

       63
       63
       +
           hash = "sha256-6PB6wjdTOa55dXV7QIsjxI77hhc95WFEjNePfupBUJQ=";

     

       64
       64
        
           fetchSubmodules = true;

     

       65
       65
        
         };

     

       66
       66
        
       

     
···

       157
       157
        
                        -I${lib.getDev libint}/include ${lib.optionalString enableElpa "$(pkg-config --variable=fcflags elpa)"} \

     

       158
       158
        
                        -I${lib.getDev sirius}/include/sirius \

     

       159
       159
        
                        -I${lib.getDev libxc}/include -I${lib.getDev libxsmm}/include \

     

       160
       160
       +
                        -I${lib.getDev hdf5-fortran}/include \

     

       160
       161
        
                        -fallow-argument-mismatch

     

       161
       162
        
           LIBS       = -lfftw3 -lfftw3_threads \

     

       162
       163
        
                        -lscalapack -lblas -llapack \

+3 -3

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

···

       2
       2
        
       

     

       3
       3
        
       buildGoModule rec {

     

       4
       4
        
         pname = "gh";

     

       5
       5
       -
         version = "2.40.1";

     

       5
       5
       +
         version = "2.41.0";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "cli";

     

       9
       9
        
           repo = "cli";

     

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

     

       11
       11
       -
           hash = "sha256-KdJZHouMTbbD/8k2VGFvRits7grbbVNUmCM6dSiJXBc=";

     

       11
       11
       +
           hash = "sha256-GkrEirunY17WgAv4XOreG+JwPQn7cRTmr7hJ3/2tSrY=";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
       -
         vendorHash = "sha256-jM9nwTMOTh+eXztLvHIwwH4qu3ZIMOtBrPEtByB9Ry8=";

     

       14
       14
       +
         vendorHash = "sha256-XBoC1sHfxInkamSHNm7Vb3AKCgIch6uYx0jJWqN7PN8=";

     

       15
       15
        
       

     

       16
       16
        
         nativeBuildInputs = [ installShellFiles ];

     

       17
       17

+21 -10

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

···

       1
       1
       -
       { lib, stdenv, fetchurl

     

       2
       2
       -
       , pkg-config, openssl, libbsd, libevent, libuuid, libossp_uuid, libmd, zlib, ncurses, bison

     

       1
       1
       +
       { lib

     

       2
       2
       +
       , stdenv

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       , pkg-config

     

       5
       5
       +
       , openssl

     

       6
       6
       +
       , libbsd

     

       7
       7
       +
       , libevent

     

       8
       8
       +
       , libuuid

     

       9
       9
       +
       , libossp_uuid

     

       10
       10
       +
       , libmd

     

       11
       11
       +
       , zlib

     

       12
       12
       +
       , ncurses

     

       13
       13
       +
       , bison

     

       3
       14
        
       , autoPatchelfHook

     

       4
       15
        
       }:

     

       5
       16
        
       

     

       6
       6
       -
       stdenv.mkDerivation rec {

     

       17
       17
       +
       stdenv.mkDerivation (finalAttrs: {

     

       7
       18
        
         pname = "got";

     

       8
       8
       -
         version = "0.94";

     

       19
       19
       +
         version = "0.95";

     

       9
       20
        
       

     

       10
       21
        
         src = fetchurl {

     

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

     

       12
       12
       -
           hash = "sha256-hG0/a+sk6uZCxR908YfZCW44qx/SIwwGO9mUaxxHZ3k=";

     

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

     

       23
       23
       +
           hash = "sha256-5on9ff76OAFmoaKTwVM0hUCGLiAZGJzt6+jCx2Nygg4=";

     

       13
       24
        
         };

     

       14
       25
        
       

     

       15
       26
        
         nativeBuildInputs = [ pkg-config bison ]

     

       16
       27
        
           ++ lib.optionals stdenv.isLinux [ autoPatchelfHook ];

     

       17
       28
        
       

     

       18
       29
        
         buildInputs = [ openssl libbsd libevent libuuid libmd zlib ncurses ]

     

       19
       19
       -
         ++ lib.optionals stdenv.isDarwin [ libossp_uuid ];

     

       30
       30
       +
           ++ lib.optionals stdenv.isDarwin [ libossp_uuid ];

     

       20
       31
        
       

     

       21
       32
        
         configureFlags = [ "--enable-gotd" ];

     

       22
       33
        
       

     

       23
       34
        
         preConfigure = lib.optionalString stdenv.isDarwin ''

     

       24
       24
       -
           # The configure script assumes dependencies on Darwin are install via

     

       35
       35
       +
           # The configure script assumes dependencies on Darwin are installed via

     

       25
       36
        
           # Homebrew or MacPorts and hardcodes assumptions about the paths of

     

       26
       37
        
           # dependencies which fails the nixpkgs configurePhase.

     

       27
       38
        
           substituteInPlace configure --replace 'xdarwin' 'xhomebrew'

     
···

       38
       49
        
       

     

       39
       50
        
         installCheckPhase = ''

     

       40
       51
        
           runHook preInstallCheck

     

       41
       41
       -
           test "$($out/bin/got --version)" = '${pname} ${version}'

     

       52
       52
       +
           test "$($out/bin/got --version)" = "${finalAttrs.pname} ${finalAttrs.version}"

     

       42
       53
        
           runHook postInstallCheck

     

       43
       54
        
         '';

     

       44
       55
        
       

     
···

       59
       70
        
           platforms = platforms.linux ++ platforms.darwin;

     

       60
       71
        
           maintainers = with maintainers; [ abbe afh ];

     

       61
       72
        
         };

     

       62
       62
       -
       }

     

       73
       73
       +
       })

+2 -2

pkgs/applications/video/kodi/addons/arteplussept/default.nix

···

       3
       3
        
       buildKodiAddon rec {

     

       4
       4
        
         pname = "arteplussept";

     

       5
       5
        
         namespace = "plugin.video.arteplussept";

     

       6
       6
       -
         version = "1.4.1";

     

       6
       6
       +
         version = "1.4.2";

     

       7
       7
        
       

     

       8
       8
        
         src = fetchzip {

     

       9
       9
        
           url = "https://mirrors.kodi.tv/addons/nexus/${namespace}/${namespace}-${version}.zip";

     

       10
       10
       -
           hash = "sha256-4lPJIFBF4zXr1bEyv9tVUPXw9JFt2by/tcOwihib6aQ=";

     

       10
       10
       +
           hash = "sha256-dqxGKaOnEYOI33Aw76zbjma5z7MqOUh367dFsV87olU=";

     

       11
       11
        
         };

     

       12
       12
        
       

     

       13
       13
        
         propagatedBuildInputs = [

+16 -10

pkgs/applications/video/obs-studio/default.nix

···

       49
       49
        
       , asio

     

       50
       50
        
       , decklinkSupport ? false

     

       51
       51
        
       , blackmagic-desktop-video

     

       52
       52
       +
       , libdatachannel

     

       53
       53
       +
       , libvpl

     

       54
       54
       +
       , qrcodegencpp

     

       52
       55
        
       }:

     

       53
       56
        
       

     

       54
       57
        
       let

     

       55
       58
        
         inherit (lib) optional optionals;

     

       59
       59
       +
       in

     

       56
       60
        
       

     

       57
       57
       -
       in

     

       58
       58
       -
       stdenv.mkDerivation rec {

     

       61
       61
       +
       stdenv.mkDerivation (finalAttrs: {

     

       59
       62
        
         pname = "obs-studio";

     

       60
       60
       -
         version = "29.1.3";

     

       63
       63
       +
         version = "30.0.2";

     

       61
       64
        
       

     

       62
       65
        
         src = fetchFromGitHub {

     

       63
       66
        
           owner = "obsproject";

     

       64
       64
       -
           repo = "obs-studio";

     

       65
       65
       -
           rev = version;

     

       66
       66
       -
           sha256 = "sha256-D0DPueMtopwz5rLgM8QcPT7DgTKcJKQHnst69EY9V6Q=";

     

       67
       67
       +
           repo = finalAttrs.pname;

     

       68
       68
       +
           rev = finalAttrs.version;

     

       69
       69
       +
           sha256 = "sha256-8pX1kqibrtDIaE1+/Pey1A5bu6MwFTXLrBOah4rsF+4=";

     

       67
       70
        
           fetchSubmodules = true;

     

       68
       71
        
         };

     

       69
       72
        
       

     
···

       132
       135
        
           nlohmann_json

     

       133
       136
        
           websocketpp

     

       134
       137
        
           asio

     

       138
       138
       +
           libdatachannel

     

       139
       139
       +
           libvpl

     

       140
       140
       +
           qrcodegencpp

     

       135
       141
        
         ]

     

       136
       142
        
         ++ optionals scriptingSupport [ luajit python3 ]

     

       137
       143
        
         ++ optional alsaSupport alsa-lib

     
···

       151
       157
        
         '';

     

       152
       158
        
       

     

       153
       159
        
         cmakeFlags = [

     

       154
       154
       -
           "-DOBS_VERSION_OVERRIDE=${version}"

     

       160
       160
       +
           "-DOBS_VERSION_OVERRIDE=${finalAttrs.version}"

     

       155
       161
        
           "-Wno-dev" # kill dev warnings that are useless for packaging

     

       156
       162
        
           # Add support for browser source

     

       157
       163
        
           "-DBUILD_BROWSER=ON"

     
···

       183
       189
        
           addOpenGLRunpath $out/lib/obs-plugins/*.so

     

       184
       190
        
       

     

       185
       191
        
           # Link libcef again after patchelfing other libs

     

       186
       186
       -
           ln -s ${libcef}/lib/libcef.so $out/lib/obs-plugins/libcef.so

     

       192
       192
       +
           ln -s ${libcef}/lib/* $out/lib/obs-plugins/

     

       187
       193
        
         '';

     

       188
       194
        
       

     

       189
       195
        
         meta = with lib; {

     
···

       194
       200
        
             video content, efficiently

     

       195
       201
        
           '';

     

       196
       202
        
           homepage = "https://obsproject.com";

     

       197
       197
       -
           maintainers = with maintainers; [ jb55 MP2E materus ];

     

       203
       203
       +
           maintainers = with maintainers; [ jb55 MP2E materus fpletz ];

     

       198
       204
        
           license = licenses.gpl2Plus;

     

       199
       205
        
           platforms = [ "x86_64-linux" "i686-linux" "aarch64-linux" ];

     

       200
       206
        
           mainProgram = "obs";

     

       201
       207
        
         };

     

       202
       202
       -
       }

     

       208
       208
       +
       })

-1

pkgs/applications/video/obs-studio/plugins/obs-hyperion/default.nix

···

       33
       33
        
           license = licenses.mit;

     

       34
       34
        
           maintainers = with maintainers; [ algram ];

     

       35
       35
        
           platforms = [ "x86_64-linux" ];

     

       36
       36
       -
           broken = true; # Not compatible with qt6 yet but required by OBS28

     

       37
       36
        
         };

     

       38
       37
        
       }

-4

pkgs/applications/video/obs-studio/plugins/obs-pipewire-audio-capture.nix

···

       27
       27
        
           "-Wno-dev"

     

       28
       28
        
         ];

     

       29
       29
        
       

     

       30
       30
       -
         preConfigure = ''

     

       31
       31
       -
           cp ${obs-studio.src}/cmake/external/ObsPluginHelpers.cmake cmake/FindLibObs.cmake

     

       32
       32
       -
         '';

     

       33
       33
       -
       

     

       34
       30
        
         meta = with lib; {

     

       35
       31
        
           description = "Audio device and application capture for OBS Studio using PipeWire";

     

       36
       32
        
           homepage = "https://github.com/dimtpap/obs-pipewire-audio-capture";

+8

pkgs/applications/video/obs-studio/plugins/obs-tuna/default.nix

···

       28
       28
        
           fetchSubmodules = true;

     

       29
       29
        
         };

     

       30
       30
        
       

     

       31
       31
       +
         # obs_frontend_add_dock() deprecated in obs 30

     

       32
       32
       +
         env.NIX_CFLAGS_COMPILE = "-Wno-error=deprecated-declarations";

     

       33
       33
       +
       

     

       31
       34
        
         patches = [

     

       32
       35
        
           # fix build with qt 6.6.0

     

       33
       36
        
           # treewide: replace deprecated qAsConst with std::as_const()

     
···

       35
       38
        
           (fetchpatch2 {

     

       36
       39
        
             url = "https://github.com/univrsal/tuna/commit/0d570e771f8d8e6ae7c85bd2b86bbf59c264789e.patch";

     

       37
       40
        
             hash = "sha256-A5idhMiM9funqhTm5XMIBqwy+FO1SaNPtgZjo+Vws6k=";

     

       41
       41
       +
           })

     

       42
       42
       +
           # fix build with obs 30

     

       43
       43
       +
           (fetchpatch2 {

     

       44
       44
       +
             url = "https://github.com/univrsal/tuna/commit/723bd3c7b4e257cf0997611426e555068de77ae7.patch";

     

       45
       45
       +
             hash = "sha256-MF5vghGYknL6q+A8BJ1yrQcEKIu9I+PWk+RZNYg3fRU=";

     

       38
       46
        
           })

     

       39
       47
        
         ];

     

       40
       48

+50 -29

pkgs/build-support/checkpoint-build.nix

···

       1
       1
       -
       { pkgs }:

     

       1
       1
       +
       { lib

     

       2
       2
       +
       , buildPackages

     

       3
       3
       +
       }:

     

       4
       4
       +
       

     

       5
       5
       +
       let

     

       6
       6
       +
         # rudimentary support for cross-compiling

     

       7
       7
       +
         # see: https://github.com/NixOS/nixpkgs/pull/279487#discussion_r1444449726

     

       8
       8
       +
         inherit (buildPackages)

     

       9
       9
       +
           mktemp

     

       10
       10
       +
           rsync

     

       11
       11
       +
           ;

     

       12
       12
       +
       in

     

       13
       13
       +
       

     

       2
       14
        
       rec {

     

       3
       15
        
         /* Prepare a derivation for local builds.

     

       4
       16
        
           *

     

       5
       5
       -
           * This function prepares checkpoint builds by provinding,

     

       6
       6
       -
           * containing the build output and the sources for cross checking.

     

       17
       17
       +
           * This function prepares checkpoint builds by storing

     

       18
       18
       +
           * the build output and the sources for cross checking.

     

       7
       19
        
           * The build output can be used later to allow checkpoint builds

     

       8
       20
        
           * by passing the derivation output to the `mkCheckpointBuild` function.

     

       9
       21
        
           *

     

       10
       10
       -
           * To build a project with checkpoints follow these steps:

     

       11
       11
       -
           * - run prepareIncrementalBuild on the desired derivation

     

       12
       12
       -
           *   e.G `incrementalBuildArtifacts = (pkgs.checkpointBuildTools.prepareCheckpointBuild pkgs.virtualbox);`

     

       13
       13
       -
           * - change something you want in the sources of the package( e.G using source override)

     

       14
       14
       -
           *   changedVBox = pkgs.virtuabox.overrideAttrs (old: {

     

       15
       15
       -
           *      src = path/to/vbox/sources;

     

       16
       16
       -
           *   }

     

       17
       17
       -
           * - use `mkCheckpointedBuild changedVBox buildOutput`

     

       22
       22
       +
           * To build a project with checkpoints, follow these steps:

     

       23
       23
       +
           * - run `prepareCheckpointBuild` on the desired derivation, e.g.

     

       24
       24
       +
           *     checkpointArtifacts = prepareCheckpointBuild virtualbox;

     

       25
       25
       +
           * - change something you want in the sources of the package,

     

       26
       26
       +
           *   e.g. using source override:

     

       27
       27
       +
           *     changedVBox = pkgs.virtuabox.overrideAttrs (old: {

     

       28
       28
       +
           *       src = path/to/vbox/sources;

     

       29
       29
       +
           *     };

     

       30
       30
       +
           * - use `mkCheckpointBuild changedVBox checkpointArtifacts`

     

       18
       31
        
           * - enjoy shorter build times

     

       19
       32
        
         */

     

       20
       33
        
         prepareCheckpointBuild = drv: drv.overrideAttrs (old: {

     

       21
       34
        
           outputs = [ "out" ];

     

       22
       35
        
           name = drv.name + "-checkpointArtifacts";

     

       23
       36
        
           # To determine differences between the state of the build directory

     

       24
       24
       -
           # from an earlier build and  a later one we store the state of the build

     

       37
       37
       +
           # from an earlier build and a later one we store the state of the build

     

       25
       38
        
           # directory before build, but after patch phases.

     

       26
       39
        
           # This way, the same derivation can be used multiple times and only changes are detected.

     

       27
       27
       -
           # Additionally Removed files are handled correctly in later builds.

     

       40
       40
       +
           # Additionally, removed files are handled correctly in later builds.

     

       28
       41
        
           preBuild = (old.preBuild or "") + ''

     

       29
       42
        
             mkdir -p $out/sources

     

       30
       43
        
             cp -r ./* $out/sources/

     

       31
       44
        
           '';

     

       32
       45
        
       

     

       33
       33
       -
           # After the build the build directory is copied again

     

       46
       46
       +
           # After the build, the build directory is copied again

     

       34
       47
        
           # to get the output files.

     

       35
       35
       -
           # We copy the complete build folder, to take care for

     

       36
       36
       -
           # Build tools, building in the source directory, instead of

     

       37
       37
       -
           # having a build root directory, e.G the Linux kernel.

     

       48
       48
       +
           # We copy the complete build folder, to take care of

     

       49
       49
       +
           # build tools that build in the source directory, instead of

     

       50
       50
       +
           # having a separate build directory such as the Linux kernel.

     

       38
       51
        
           installPhase = ''

     

       39
       52
        
             runHook preCheckpointInstall

     

       40
       53
        
             mkdir -p $out/outputs

     
···

       44
       57
        
         });

     

       45
       58
        
       

     

       46
       59
        
         /* Build a derivation based on the checkpoint output generated by

     

       47
       47
       -
           * the `prepareCheckpointBuild function.

     

       60
       60
       +
           * the `prepareCheckpointBuild` function.

     

       48
       61
        
           *

     

       49
       62
        
           * Usage:

     

       50
       63
        
           * let

     

       51
       51
       -
           *   checkpointArtifacts = prepareCheckpointBuild drv

     

       52
       52
       -
           * in mkCheckpointedBuild drv checkpointArtifacts

     

       64
       64
       +
           *   checkpointArtifacts = prepareCheckpointBuild drv;

     

       65
       65
       +
           * in mkCheckpointBuild drv checkpointArtifacts

     

       53
       66
        
         */

     

       54
       54
       -
         mkCheckpointedBuild = drv: previousBuildArtifacts: drv.overrideAttrs (old: {

     

       67
       67
       +
         mkCheckpointBuild = drv: checkpointArtifacts: drv.overrideAttrs (old: {

     

       55
       68
        
           # The actual checkpoint build phase.

     

       56
       56
       -
           # We compare the changed sources from a previous build with the current and create a patch

     

       57
       57
       -
           # Afterwards we clean the build directory to copy the previous output files (Including the sources)

     

       58
       58
       -
           # The source difference patch is applied to get the latest changes again to allow short build times.

     

       69
       69
       +
           # We compare the changed sources from a previous build with the current and create a patch.

     

       70
       70
       +
           # Afterwards we clean the build directory and copy the previous output files (including the sources).

     

       71
       71
       +
           # The source difference patch is then applied to get the latest changes again to allow short build times.

     

       59
       72
        
           preBuild = (old.preBuild or "") + ''

     

       60
       73
        
             set +e

     

       61
       61
       -
             diff -ur ${previousBuildArtifacts}/sources ./ > sourceDifference.patch

     

       74
       74
       +
             sourceDifferencePatchFile=$(${mktemp}/bin/mktemp)

     

       75
       75
       +
             diff -ur ${checkpointArtifacts}/sources ./ > "$sourceDifferencePatchFile"

     

       62
       76
        
             set -e

     

       63
       63
       -
             shopt -s extglob dotglob

     

       64
       64
       -
             rm -r !("sourceDifference.patch")

     

       65
       65
       -
             ${pkgs.rsync}/bin/rsync -cutU --chown=$USER:$USER --chmod=+w -r ${previousBuildArtifacts}/outputs/* .

     

       66
       66
       -
             patch -p 1 -i sourceDifference.patch

     

       77
       77
       +
             shopt -s dotglob

     

       78
       78
       +
             rm -r *

     

       79
       79
       +
             ${rsync}/bin/rsync \

     

       80
       80
       +
               --checksum --times --atimes --chown=$USER:$USER --chmod=+w \

     

       81
       81
       +
               -r ${checkpointArtifacts}/outputs/ .

     

       82
       82
       +
             patch -p 1 -i "$sourceDifferencePatchFile"

     

       83
       83
       +
             rm "$sourceDifferencePatchFile"

     

       67
       84
        
           '';

     

       68
       85
        
         });

     

       86
       86
       +
       

     

       87
       87
       +
         mkCheckpointedBuild = lib.warn

     

       88
       88
       +
           "`mkCheckpointedBuild` is deprecated, use `mkCheckpointBuild` instead!"

     

       89
       89
       +
           mkCheckpointBuild;

     

       69
       90
        
       }

+24

pkgs/by-name/fi/fileinfo/package.nix

···

       1
       1
       +
       { lib

     

       2
       2
       +
       , python3Packages

     

       3
       3
       +
       , fetchFromGitHub

     

       4
       4
       +
       }:

     

       5
       5
       +
       python3Packages.buildPythonApplication {

     

       6
       6
       +
         pname = "fileinfo";

     

       7
       7
       +
         version = "unstable-2022-09-16";

     

       8
       8
       +
         src = fetchFromGitHub {

     

       9
       9
       +
           owner = "sdushantha";

     

       10
       10
       +
           repo = "fileinfo";

     

       11
       11
       +
           rev = "503f26189ad5043bad3fe71333dd5ba3ffbce485";

     

       12
       12
       +
           hash = "sha256-tEmCsR3LmTxeDZAbMvbIwqp/6uaGNUhgGlm18gdsnOw=";

     

       13
       13
       +
         };

     

       14
       14
       +
       

     

       15
       15
       +
         propagatedBuildInputs = with python3Packages; [ requests ];

     

       16
       16
       +
       

     

       17
       17
       +
         meta = with lib; {

     

       18
       18
       +
           homepage = "https://github.com/sdushantha/fileinfo";

     

       19
       19
       +
           description = "A file extension metadata lookup tool";

     

       20
       20
       +
           license = licenses.mit;

     

       21
       21
       +
           maintainers = with maintainers; [ h7x4 ];

     

       22
       22
       +
           mainProgram = "fileinfo";

     

       23
       23
       +
         };

     

       24
       24
       +
       }

+41

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

···

       1
       1
       +
       { stdenv

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchFromGitHub

     

       4
       4
       +
       , cmake

     

       5
       5
       +
       , pkg-config

     

       6
       6
       +
       }:

     

       7
       7
       +
       

     

       8
       8
       +
       stdenv.mkDerivation (finalAttrs: {

     

       9
       9
       +
         pname = "libvpl";

     

       10
       10
       +
         version = "2.10.1";

     

       11
       11
       +
       

     

       12
       12
       +
         src = fetchFromGitHub {

     

       13
       13
       +
           owner = "intel";

     

       14
       14
       +
           repo = finalAttrs.pname;

     

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

     

       16
       16
       +
           hash = "sha256-2yfJo4iwI/h0CJ+mJJ3cAyG5S7KksUibwJHebF3MR+E=";

     

       17
       17
       +
         };

     

       18
       18
       +
       

     

       19
       19
       +
         nativeBuildInputs = [

     

       20
       20
       +
           cmake

     

       21
       21
       +
           pkg-config

     

       22
       22
       +
         ];

     

       23
       23
       +
       

     

       24
       24
       +
         cmakeFlags = [

     

       25
       25
       +
             "-DCMAKE_BUILD_TYPE=Release"

     

       26
       26
       +
             "-DENABLE_DRI3=ON"

     

       27
       27
       +
             "-DENABLE_DRM=ON"

     

       28
       28
       +
             "-DENABLE_VA=ON"

     

       29
       29
       +
             "-DENABLE_WAYLAND=ON"

     

       30
       30
       +
             "-DENABLE_X11=ON"

     

       31
       31
       +
             "-DINSTALL_EXAMPLE_CODE=OFF"

     

       32
       32
       +
             "-DBUILD_TOOLS=OFF"

     

       33
       33
       +
         ];

     

       34
       34
       +
       

     

       35
       35
       +
         meta = with lib; {

     

       36
       36
       +
           description = "Intel Video Processing Library";

     

       37
       37
       +
           homepage = "https://intel.github.io/libvpl/";

     

       38
       38
       +
           license = licenses.mit;

     

       39
       39
       +
           platforms = platforms.linux;

     

       40
       40
       +
         };

     

       41
       41
       +
       })

+32

pkgs/by-name/qr/qrcodegencpp/package.nix

···

       1
       1
       +
       { lib

     

       2
       2
       +
       , stdenv

     

       3
       3
       +
       , qrcodegen

     

       4
       4
       +
       }:

     

       5
       5
       +
       

     

       6
       6
       +
       stdenv.mkDerivation (finalAttrs: {

     

       7
       7
       +
         pname = "qrcodegencpp";

     

       8
       8
       +
         version = qrcodegen.version;

     

       9
       9
       +
       

     

       10
       10
       +
         src = qrcodegen.src;

     

       11
       11
       +
       

     

       12
       12
       +
         sourceRoot = "${finalAttrs.src.name}/cpp";

     

       13
       13
       +
       

     

       14
       14
       +
         nativeBuildInputs = lib.optionals stdenv.cc.isClang [

     

       15
       15
       +
           stdenv.cc.cc.libllvm.out

     

       16
       16
       +
         ];

     

       17
       17
       +
       

     

       18
       18
       +
         makeFlags = lib.optionals stdenv.cc.isClang [ "AR=llvm-ar" ];

     

       19
       19
       +
       

     

       20
       20
       +
         installPhase = ''

     

       21
       21
       +
           runHook preInstall

     

       22
       22
       +
       

     

       23
       23
       +
           install -Dt $out/lib/ libqrcodegencpp.a

     

       24
       24
       +
           install -Dt $out/include/qrcodegen/ qrcodegen.hpp

     

       25
       25
       +
       

     

       26
       26
       +
           runHook postInstall

     

       27
       27
       +
         '';

     

       28
       28
       +
       

     

       29
       29
       +
         meta = {

     

       30
       30
       +
           inherit (qrcodegen.meta) description homepage license maintainers platforms;

     

       31
       31
       +
         };

     

       32
       32
       +
       })

+1 -1

pkgs/development/cuda-modules/setup-hooks/auto-add-cuda-compat-runpath.sh

···

       10
       10
        
       autoAddCudaCompatRunpathPhase() (

     

       11
       11
        
         local outputPaths

     

       12
       12
        
         mapfile -t outputPaths < <(for o in $(getAllOutputNames); do echo "${!o}"; done)

     

       13
       13
       -
         find "${outputPaths[@]}" -type f -executable -print0  | while IFS= read -rd "" f; do

     

       13
       13
       +
         find "${outputPaths[@]}" -type f -print0  | while IFS= read -rd "" f; do

     

       14
       14
        
           if isELF "$f"; then

     

       15
       15
        
             # patchelf returns an error on statically linked ELF files

     

       16
       16
        
             if elfHasDynamicSection "$f" ; then

+1 -1

pkgs/development/cuda-modules/setup-hooks/auto-add-opengl-runpath-hook.sh

···

       9
       9
        
       autoAddOpenGLRunpathPhase() (

     

       10
       10
        
         local outputPaths

     

       11
       11
        
         mapfile -t outputPaths < <(for o in $(getAllOutputNames); do echo "${!o}"; done)

     

       12
       12
       -
         find "${outputPaths[@]}" -type f -executable -print0  | while IFS= read -rd "" f; do

     

       12
       12
       +
         find "${outputPaths[@]}" -type f -print0  | while IFS= read -rd "" f; do

     

       13
       13
        
           if isELF "$f"; then

     

       14
       14
        
             # patchelf returns an error on statically linked ELF files

     

       15
       15
        
             if elfHasDynamicSection "$f" ; then

+8

pkgs/development/libraries/libcef/default.nix

···

       30
       30
        
       }:

     

       31
       31
        
       

     

       32
       32
        
       let

     

       33
       33
       +
         gl_rpath = lib.makeLibraryPath [

     

       34
       34
       +
           stdenv.cc.cc.lib

     

       35
       35
       +
         ];

     

       36
       36
       +
       

     

       33
       37
        
         rpath = lib.makeLibraryPath [

     

       34
       38
        
           glib

     

       35
       39
        
           nss

     
···

       92
       96
        
           mkdir -p $out/lib/ $out/share/cef/

     

       93
       97
        
           cp libcef_dll_wrapper/libcef_dll_wrapper.a $out/lib/

     

       94
       98
        
           cp ../Release/libcef.so $out/lib/

     

       99
       99
       +
           cp ../Release/libEGL.so $out/lib/

     

       100
       100
       +
           cp ../Release/libGLESv2.so $out/lib/

     

       95
       101
        
           patchelf --set-rpath "${rpath}" $out/lib/libcef.so

     

       102
       102
       +
           patchelf --set-rpath "${gl_rpath}" $out/lib/libEGL.so

     

       103
       103
       +
           patchelf --set-rpath "${gl_rpath}" $out/lib/libGLESv2.so

     

       96
       104
        
           cp ../Release/*.bin $out/share/cef/

     

       97
       105
        
           cp -r ../Resources/* $out/share/cef/

     

       98
       106
        
           cp -r ../include $out/

+9 -8

pkgs/development/libraries/tbb/2020_3.nix

···

       1
       1
        
       { lib

     

       2
       2
        
       , stdenv

     

       3
       3
       +
       , fetchpatch

     

       3
       4
        
       , fetchurl

     

       4
       5
        
       , fetchFromGitHub

     

       5
       6
        
       , fixDarwinDylibNames

     
···

       20
       21
        
       

     

       21
       22
        
         patches = [

     

       22
       23
        
           # Fixes build with Musl.

     

       23
       23
       -
           (fetchurl {

     

       24
       24
       +
           (fetchpatch {

     

       24
       25
        
             url = "https://github.com/openembedded/meta-openembedded/raw/39185eb1d1615e919e3ae14ae63b8ed7d3e5d83f/meta-oe/recipes-support/tbb/tbb/GLIBC-PREREQ-is-not-defined-on-musl.patch";

     

       25
       25
       -
             sha256 = "gUfXQ9OZQ82qD6brgauBCsKdjLvyHafMc18B+KxZoYs=";

     

       26
       26
       +
             hash = "sha256-Oo5FSBPPBaOziWEBOlRmTmbulExMsAmQWBR5faOj1a0=";

     

       26
       27
        
           })

     

       27
       28
        
       

     

       28
       29
        
           # Fixes build with Musl.

     

       29
       29
       -
           (fetchurl {

     

       30
       30
       +
           (fetchpatch {

     

       30
       31
        
             url = "https://github.com/openembedded/meta-openembedded/raw/39185eb1d1615e919e3ae14ae63b8ed7d3e5d83f/meta-oe/recipes-support/tbb/tbb/0001-mallinfo-is-glibc-specific-API-mark-it-so.patch";

     

       31
       31
       -
             sha256 = "fhorfqO1hHKZ61uq+yTR7eQ8KYdyLwpM3K7WpwJpV74=";

     

       32
       32
       +
             hash = "sha256-xp8J/il855VTFIKCN/bFtf+vif6HzcVl4t4/L9nW/xk=";

     

       32
       33
        
           })

     

       33
       34
        
       

     

       34
       35
        
           # Fixes build with upcoming gcc-13:

     

       35
       36
        
           #  https://github.com/oneapi-src/oneTBB/pull/833

     

       36
       36
       -
           (fetchurl {

     

       37
       37
       +
           (fetchpatch {

     

       37
       38
        
             name = "gcc-13.patch";

     

       38
       39
        
             url = "https://github.com/oneapi-src/oneTBB/pull/833/commits/c18342ba667d1f33f5e9a773aa86b091a9694b97.patch";

     

       39
       39
       -
             sha256 = "ZUExE3nsW80Z5GPWZnDNuDiHHaD1EF7qNl/G5M+Wcxg=";

     

       40
       40
       +
             hash = "sha256-LWgf7Rm6Zp4TJdvMqnAkoAebbVS+WV2kB+4iY6jRka4=";

     

       40
       41
        
           })

     

       41
       42
        
       

     

       42
       43
        
           # Fixes build for aarch64-darwin

     

       43
       43
       -
           (fetchurl {

     

       44
       44
       +
           (fetchpatch {

     

       44
       45
        
             name = "aarch64-darwin.patch";

     

       45
       46
        
             url = "https://github.com/oneapi-src/oneTBB/pull/258/commits/86f6dcdc17a8f5ef2382faaef860cfa5243984fe.patch";

     

       46
       46
       -
             sha256 = "sha256-JXqrFPCb3q1vfxk752tQu7HhApCB4YH2LoVnGRwmspk=";

     

       47
       47
       +
             hash = "sha256-+sNU8yEsVVmQYOCKmlNiyJfKmB/U0GKAmrydwkfrDFQ=";

     

       47
       48
        
           })

     

       48
       49
        
         ];

     

       49
       50

+2 -2

pkgs/development/mobile/maestro/default.nix

···

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation rec {

     

       4
       4
        
         pname = "maestro";

     

       5
       5
       -
         version = "1.34.1";

     

       5
       5
       +
         version = "1.35.0";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchurl {

     

       8
       8
        
           url = "https://github.com/mobile-dev-inc/maestro/releases/download/cli-${version}/maestro.zip";

     

       9
       9
       -
           sha256 = "0whnhcf7a3j01693254qqwfk9d3xa4icv4kyqkn4ihxyibznb91d";

     

       9
       9
       +
           sha256 = "1rr3ihirga9jjw1n9z45hby6j68d0q11alzhqz4yv2ibvrjykzai";

     

       10
       10
        
         };

     

       11
       11
        
       

     

       12
       12
        
         dontUnpack = true;

+60

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

···

       1
       1
       +
       { lib

     

       2
       2
       +
       , buildPythonPackage

     

       3
       3
       +
       , fetchFromGitHub

     

       4
       4
       +
       , setuptools

     

       5
       5
       +
       , strct

     

       6
       6
       +
       , pytestCheckHook

     

       7
       7
       +
       , pyyaml

     

       8
       8
       +
       }:

     

       9
       9
       +
       

     

       10
       10
       +
       buildPythonPackage rec {

     

       11
       11
       +
         pname = "birch";

     

       12
       12
       +
         version = "0.0.35";

     

       13
       13
       +
         pyproject = true;

     

       14
       14
       +
       

     

       15
       15
       +
         src = fetchFromGitHub {

     

       16
       16
       +
           owner = "shaypal5";

     

       17
       17
       +
           repo = "birch";

     

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

     

       19
       19
       +
           hash = "sha256-KdQZzQJvJ+logpcLQfaqqEEZJ/9VmNTQX/a4v0oBC98=";

     

       20
       20
       +
         };

     

       21
       21
       +
       

     

       22
       22
       +
         postPatch = ''

     

       23
       23
       +
           substituteInPlace pytest.ini \

     

       24
       24
       +
             --replace  \

     

       25
       25
       +
               "--cov" \

     

       26
       26
       +
               "#--cov"

     

       27
       27
       +
         '';

     

       28
       28
       +
       

     

       29
       29
       +
         nativeBuildInputs = [

     

       30
       30
       +
           setuptools

     

       31
       31
       +
         ];

     

       32
       32
       +
       

     

       33
       33
       +
         propagatedBuildInputs = [

     

       34
       34
       +
           strct

     

       35
       35
       +
         ];

     

       36
       36
       +
       

     

       37
       37
       +
         pythonImportsCheck = [

     

       38
       38
       +
           "birch"

     

       39
       39
       +
           "birch.casters"

     

       40
       40
       +
           "birch.exceptions"

     

       41
       41
       +
           "birch.paths"

     

       42
       42
       +
         ];

     

       43
       43
       +
       

     

       44
       44
       +
         nativeCheckInputs = [

     

       45
       45
       +
           pytestCheckHook

     

       46
       46
       +
           pyyaml

     

       47
       47
       +
         ];

     

       48
       48
       +
       

     

       49
       49
       +
         preCheck = ''

     

       50
       50
       +
           export HOME="$(mktemp -d)"

     

       51
       51
       +
         '';

     

       52
       52
       +
       

     

       53
       53
       +
       

     

       54
       54
       +
         meta = with lib; {

     

       55
       55
       +
           description = "Simple hierarchical configuration for Python packages";

     

       56
       56
       +
           homepage = "https://github.com/shaypal5/birch";

     

       57
       57
       +
           license = licenses.mit;

     

       58
       58
       +
           maintainers = with maintainers; [ pbsds ];

     

       59
       59
       +
         };

     

       60
       60
       +
       }

+10 -8

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

···

       1
       1
        
       { lib

     

       2
       2
        
       , buildPythonPackage

     

       3
       3
        
       , pythonOlder

     

       4
       4
       -
       , fetchPypi

     

       4
       4
       +
       , fetchFromGitHub

     

       5
       5
        
       , pythonRelaxDepsHook

     

       6
       6
        
       , setuptools

     

       7
       7
        
       , watchdog

     

       8
       8
        
       , portalocker

     

       9
       9
       -
       , pathtools

     

       10
       9
        
       , pytestCheckHook

     

       11
       10
        
       , pymongo

     

       12
       11
        
       , dnspython

     

       13
       12
        
       , pymongo-inmemory

     

       14
       13
        
       , pandas

     

       14
       14
       +
       , birch

     

       15
       15
        
       }:

     

       16
       16
        
       

     

       17
       17
        
       buildPythonPackage rec {

     

       18
       18
        
         pname = "cachier";

     

       19
       19
       -
         version = "2.2.1";

     

       20
       20
       -
         format = "setuptools";

     

       19
       19
       +
         version = "2.2.2";

     

       20
       20
       +
         pyproject = true;

     

       21
       21
        
       

     

       22
       22
        
         disabled = pythonOlder "3.8";

     

       23
       23
        
       

     

       24
       24
       -
         src = fetchPypi {

     

       25
       25
       -
           inherit pname version;

     

       26
       26
       -
           hash = "sha256-nm98LT87Z7yErKvIqMp93OEX9TDojqqtItgryHgSQJQ=";

     

       24
       24
       +
         src = fetchFromGitHub {

     

       25
       25
       +
           owner = "python-cachier";

     

       26
       26
       +
           repo = "cachier";

     

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

     

       28
       28
       +
           hash = "sha256-zUZqT4SIwZRqhRS/wHIzIYVULnp5aYcytCQd17T0D/4=";

     

       27
       29
        
         };

     

       28
       30
        
       

     

       29
       31
        
         pythonRemoveDeps = [ "setuptools" ];

     
···

       36
       38
        
         propagatedBuildInputs = [

     

       37
       39
        
           watchdog

     

       38
       40
        
           portalocker

     

       39
       39
       -
           pathtools

     

       40
       41
        
         ];

     

       41
       42
        
       

     

       42
       43
        
         preCheck = ''

     
···

       52
       53
        
           dnspython

     

       53
       54
        
           pymongo-inmemory

     

       54
       55
        
           pandas

     

       56
       56
       +
           birch

     

       55
       57
        
         ];

     

       56
       58
        
       

     

       57
       59
        
         disabledTests = [

+2 -2

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

···

       9
       9
        
       

     

       10
       10
        
       buildPythonPackage rec {

     

       11
       11
        
         pname = "ftputil";

     

       12
       12
       -
         version = "5.0.4";

     

       12
       12
       +
         version = "5.1.0";

     

       13
       13
        
         format = "setuptools";

     

       14
       14
        
       

     

       15
       15
        
         disabled = pythonOlder "3.6";

     

       16
       16
        
       

     

       17
       17
        
         src = fetchPypi {

     

       18
       18
        
           inherit pname version;

     

       19
       19
       -
           hash = "sha256-aInbhkndINm21ApsXw+EzPNAp9rB4L/A8AJAkPwq+zM=";

     

       19
       19
       +
           hash = "sha256-6eYtP9MH75xS5Dsz/ZJ1n8lMBNi1F4+F9kGxg5BtQ1M=";

     

       20
       20
        
         };

     

       21
       21
        
       

     

       22
       22
        
         nativeCheckInputs = [

+2 -2

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

···

       15
       15
        
       , httpx

     

       16
       16
        
       }:

     

       17
       17
        
       let

     

       18
       18
       -
         version = "1.15.0";

     

       18
       18
       +
         version = "1.16.19";

     

       19
       19
        
       in

     

       20
       20
        
       buildPythonPackage rec {

     

       21
       21
        
         pname = "litellm";

     
···

       26
       26
        
           owner = "BerriAI";

     

       27
       27
        
           repo = "litellm";

     

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

     

       29
       29
       -
           hash = "sha256-s3Ue/N04YZHEfEnVxPHupRSVDHxWjVse8FDlRF5yKCk=";

     

       29
       29
       +
           hash = "sha256-KNQuTgJj7oLJsxfi8g9ShC5WHyrdpZGI5Nfgxzu/eak=";

     

       30
       30
        
         };

     

       31
       31
        
       

     

       32
       32
        
         postPatch = ''

+2 -2

pkgs/development/python-modules/opencensus-ext-azure/default.nix

···

       11
       11
        
       

     

       12
       12
        
       buildPythonPackage rec {

     

       13
       13
        
         pname = "opencensus-ext-azure";

     

       14
       14
       -
         version = "1.1.12";

     

       14
       14
       +
         version = "1.1.13";

     

       15
       15
        
         format = "setuptools";

     

       16
       16
        
       

     

       17
       17
        
         disabled = pythonOlder "3.4";

     

       18
       18
        
       

     

       19
       19
        
         src = fetchPypi {

     

       20
       20
        
           inherit pname version;

     

       21
       21
       -
           hash = "sha256-hrseR84dIKytlq08Efjvsvp6tensSJbzBj2F+JlJBGI=";

     

       21
       21
       +
           hash = "sha256-rsMEchdwBTebpWpwKgl9YYxfV1WOG7ZnbsdflIEwaSo=";

     

       22
       22
        
         };

     

       23
       23
        
       

     

       24
       24
        
         propagatedBuildInputs = [

+3 -3

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

···

       16
       16
        
       , python-docx

     

       17
       17
        
       }:

     

       18
       18
        
       let

     

       19
       19
       -
         version = "0.5.6";

     

       19
       19
       +
         version = "0.5.7";

     

       20
       20
        
       in

     

       21
       21
        
       buildPythonPackage {

     

       22
       22
        
         pname = "pdf2docx";

     
···

       26
       26
        
         src = fetchFromGitHub {

     

       27
       27
        
           owner = "dothinking";

     

       28
       28
        
           repo = "pdf2docx";

     

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

     

       30
       30
       -
           hash = "sha256-NrT4GURQIJbqnHstfJrPzwLXT9c2oGBi4QJ6eGIFwu4=";

     

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

     

       30
       30
       +
           hash = "sha256-GDftANn+ioaNR28VfRFDuFgdKoy7D4xiy0ezvWJ3zy0=";

     

       31
       31
        
         };

     

       32
       32
        
       

     

       33
       33
        
         nativeBuildInputs = [

+15 -10

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

···

       1
       1
        
       { lib

     

       2
       2
        
       , buildPythonPackage

     

       3
       3
       -
       , isPy3k

     

       4
       4
       -
       , fetchPypi

     

       3
       3
       +
       , pythonOlder

     

       4
       4
       +
       , fetchFromGitHub

     

       5
       5
        
       , substituteAll

     

       6
       6
        
       , graphviz

     

       7
       7
        
       , coreutils

     

       8
       8
        
       , pkg-config

     

       9
       9
       +
       , setuptools

     

       9
       10
        
       , pytest

     

       10
       11
        
       }:

     

       11
       12
        
       

     

       12
       13
        
       buildPythonPackage rec {

     

       13
       14
        
         pname = "pygraphviz";

     

       14
       14
       -
         version = "1.11";

     

       15
       15
       -
         format = "setuptools";

     

       15
       15
       +
         version = "1.12";

     

       16
       16
       +
         pyproject = true;

     

       16
       17
        
       

     

       17
       17
       -
         disabled = !isPy3k;

     

       18
       18
       +
         disabled = pythonOlder "3.10";

     

       18
       19
        
       

     

       19
       19
       -
         src = fetchPypi {

     

       20
       20
       -
           inherit pname version;

     

       21
       21
       -
           hash = "sha256-qX61ztJm9FBT67HyxsbSkJFpBQPjpcFL5/kIs3sG8tQ=";

     

       22
       22
       -
           extension = "zip";

     

       20
       20
       +
         src = fetchFromGitHub {

     

       21
       21
       +
           owner = "pygraphviz";

     

       22
       22
       +
           repo = "pygraphviz";

     

       23
       23
       +
           rev = "pygraphviz-${version}";

     

       24
       24
       +
           hash = "sha256-XDP77H724eiMa/V18OtLxpUpxlIVDmcFLMYOAbazquo=";

     

       23
       25
        
         };

     

       24
       26
        
       

     

       25
       27
        
         patches = [

     
···

       30
       32
        
           })

     

       31
       33
        
         ];

     

       32
       34
        
       

     

       33
       33
       -
         nativeBuildInputs = [ pkg-config ];

     

       35
       35
       +
         nativeBuildInputs = [

     

       36
       36
       +
           pkg-config

     

       37
       37
       +
           setuptools

     

       38
       38
       +
         ];

     

       34
       39
        
       

     

       35
       40
        
         buildInputs = [ graphviz ];

     

       36
       41

+2 -2

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

···

       7
       7
        
       

     

       8
       8
        
       buildPythonPackage rec {

     

       9
       9
        
         pname = "rapidgzip";

     

       10
       10
       -
         version = "0.11.1";

     

       10
       10
       +
         version = "0.12.1";

     

       11
       11
        
         format = "setuptools";

     

       12
       12
        
       

     

       13
       13
        
         disabled = pythonOlder "3.6";

     

       14
       14
        
       

     

       15
       15
        
         src = fetchPypi {

     

       16
       16
        
           inherit pname version;

     

       17
       17
       -
           hash = "sha256-pcKO9BovkUDlRjE8MZQEfTSutVMB/9beyAyP3vChMUE=";

     

       17
       17
       +
           hash = "sha256-s4MLxhwoGS7Zvx6k5qh1PWpyTRBUBGVIkPW9q94u+2Q=";

     

       18
       18
        
         };

     

       19
       19
        
       

     

       20
       20
        
         nativeBuildInputs = [ nasm ];

+52

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

···

       1
       1
       +
       { lib

     

       2
       2
       +
       , fetchFromGitHub

     

       3
       3
       +
       , buildPythonPackage

     

       4
       4
       +
       , setuptools

     

       5
       5
       +
       , pytestCheckHook

     

       6
       6
       +
       , sortedcontainers

     

       7
       7
       +
       }:

     

       8
       8
       +
       

     

       9
       9
       +
       buildPythonPackage rec {

     

       10
       10
       +
         pname = "strct";

     

       11
       11
       +
         version = "0.0.32";

     

       12
       12
       +
         pyproject = true;

     

       13
       13
       +
       

     

       14
       14
       +
         src = fetchFromGitHub {

     

       15
       15
       +
           owner = "shaypal5";

     

       16
       16
       +
           repo = "strct";

     

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

     

       18
       18
       +
           hash = "sha256-ctafvdfSOdp7tlCUYg7d5XTXR1qBcWvOVtGtNUnhYIw=";

     

       19
       19
       +
         };

     

       20
       20
       +
       

     

       21
       21
       +
         postPatch = ''

     

       22
       22
       +
           substituteInPlace pytest.ini \

     

       23
       23
       +
             --replace  \

     

       24
       24
       +
               "--cov" \

     

       25
       25
       +
               "#--cov"

     

       26
       26
       +
         '';

     

       27
       27
       +
       

     

       28
       28
       +
         nativeBuildInputs = [

     

       29
       29
       +
           setuptools

     

       30
       30
       +
         ];

     

       31
       31
       +
       

     

       32
       32
       +
         nativeCheckInputs = [

     

       33
       33
       +
           pytestCheckHook

     

       34
       34
       +
           sortedcontainers

     

       35
       35
       +
         ];

     

       36
       36
       +
       

     

       37
       37
       +
         pythonImportsCheck = [

     

       38
       38
       +
           "strct"

     

       39
       39
       +
           "strct.dicts"

     

       40
       40
       +
           "strct.hash"

     

       41
       41
       +
           "strct.lists"

     

       42
       42
       +
           "strct.sets"

     

       43
       43
       +
           "strct.sortedlists"

     

       44
       44
       +
         ];

     

       45
       45
       +
       

     

       46
       46
       +
         meta = with lib; {

     

       47
       47
       +
           description = "A small pure-python package for data structure related utility functions";

     

       48
       48
       +
           homepage = "https://github.com/shaypal5/strct";

     

       49
       49
       +
           license = licenses.mit;

     

       50
       50
       +
           maintainers = with maintainers; [ pbsds ];

     

       51
       51
       +
         };

     

       52
       52
       +
       }

+39 -45

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

···

       1
       1
        
       { lib

     

       2
       2
        
       , stdenv

     

       3
       3
       +
       , linkFarm

     

       3
       4
        
       , buildPythonPackage

     

       4
       5
        
       , cargo

     

       5
       6
        
       , datasets

     
···

       21
       22
        
       let

     

       22
       23
        
         # See https://github.com/huggingface/tokenizers/blob/main/bindings/python/tests/utils.py for details

     

       23
       24
        
         # about URLs and file names

     

       24
       24
       -
         robertaVocab = fetchurl {

     

       25
       25
       -
           url = "https://s3.amazonaws.com/models.huggingface.co/bert/roberta-base-vocab.json";

     

       26
       26
       -
           sha256 = "0m86wpkfb2gdh9x9i9ng2fvwk1rva4p0s98xw996nrjxs7166zwy";

     

       27
       27
       -
         };

     

       28
       28
       -
         robertaMerges = fetchurl {

     

       29
       29
       -
           url = "https://s3.amazonaws.com/models.huggingface.co/bert/roberta-base-merges.txt";

     

       30
       30
       -
           sha256 = "1idd4rvkpqqbks51i2vjbd928inw7slij9l4r063w3y5fd3ndq8w";

     

       31
       31
       -
         };

     

       32
       32
       -
         albertVocab = fetchurl {

     

       33
       33
       -
           url = "https://s3.amazonaws.com/models.huggingface.co/bert/albert-base-v1-tokenizer.json";

     

       34
       34
       -
           sha256 = "1hra9pn8rczx7378z88zjclw2qsdrdwq20m56sy42s2crbas6akf";

     

       35
       35
       -
         };

     

       36
       36
       -
         bertVocab = fetchurl {

     

       37
       37
       -
           url = "https://s3.amazonaws.com/models.huggingface.co/bert/bert-base-uncased-vocab.txt";

     

       38
       38
       -
           sha256 = "18rq42cmqa8zanydsbzrb34xwy4l6cz1y900r4kls57cbhvyvv07";

     

       39
       39
       -
         };

     

       40
       40
       -
         norvigBig = fetchurl {

     

       41
       41
       -
           url = "https://norvig.com/big.txt";

     

       42
       42
       -
           sha256 = "0yz80icdly7na03cfpl0nfk5h3j3cam55rj486n03wph81ynq1ps";

     

       43
       43
       -
         };

     

       44
       44
       -
         docPipelineTokenizer = fetchurl {

     

       45
       45
       -
           url = "https://s3.amazonaws.com/models.huggingface.co/bert/anthony/doc-pipeline/tokenizer.json";

     

       46
       46
       -
           hash = "sha256-i533xC8J5CDMNxBjo+p6avIM8UOcui8RmGAmK0GmfBc=";

     

       47
       47
       -
         };

     

       48
       48
       -
         docQuicktourTokenizer = fetchurl {

     

       49
       49
       -
           url = "https://s3.amazonaws.com/models.huggingface.co/bert/anthony/doc-quicktour/tokenizer.json";

     

       50
       50
       -
           hash = "sha256-ipY9d5DR5nxoO6kj7rItueZ9AO5wq9+Nzr6GuEIfIBI=";

     

       51
       51
       -
         };

     

       52
       52
       -
         openaiVocab = fetchurl {

     

       53
       53
       -
           url = "https://s3.amazonaws.com/models.huggingface.co/bert/openai-gpt-vocab.json";

     

       54
       54
       -
           sha256 = "0y40gc9bixj5rxv674br1rxmxkd3ly29p80x1596h8yywwcrpx7x";

     

       55
       55
       -
         };

     

       56
       56
       -
         openaiMerges = fetchurl {

     

       57
       57
       -
           url = "https://s3.amazonaws.com/models.huggingface.co/bert/openai-gpt-merges.txt";

     

       58
       58
       -
           sha256 = "09a754pm4djjglv3x5pkgwd6f79i2rq8ydg0f7c3q1wmwqdbba8f";

     

       25
       25
       +
         test-data = linkFarm "tokenizers-test-data" {

     

       26
       26
       +
           "roberta-base-vocab.json" = fetchurl {

     

       27
       27
       +
             url = "https://s3.amazonaws.com/models.huggingface.co/bert/roberta-base-vocab.json";

     

       28
       28
       +
             sha256 = "0m86wpkfb2gdh9x9i9ng2fvwk1rva4p0s98xw996nrjxs7166zwy";

     

       29
       29
       +
           };

     

       30
       30
       +
           "roberta-base-merges.txt" = fetchurl {

     

       31
       31
       +
             url = "https://s3.amazonaws.com/models.huggingface.co/bert/roberta-base-merges.txt";

     

       32
       32
       +
             sha256 = "1idd4rvkpqqbks51i2vjbd928inw7slij9l4r063w3y5fd3ndq8w";

     

       33
       33
       +
           };

     

       34
       34
       +
           "albert-base-v1-tokenizer.json" = fetchurl {

     

       35
       35
       +
             url = "https://s3.amazonaws.com/models.huggingface.co/bert/albert-base-v1-tokenizer.json";

     

       36
       36
       +
             sha256 = "1hra9pn8rczx7378z88zjclw2qsdrdwq20m56sy42s2crbas6akf";

     

       37
       37
       +
           };

     

       38
       38
       +
           "bert-base-uncased-vocab.txt" = fetchurl {

     

       39
       39
       +
             url = "https://s3.amazonaws.com/models.huggingface.co/bert/bert-base-uncased-vocab.txt";

     

       40
       40
       +
             sha256 = "18rq42cmqa8zanydsbzrb34xwy4l6cz1y900r4kls57cbhvyvv07";

     

       41
       41
       +
           };

     

       42
       42
       +
           "big.txt" = fetchurl {

     

       43
       43
       +
             url = "https://norvig.com/big.txt";

     

       44
       44
       +
             sha256 = "0yz80icdly7na03cfpl0nfk5h3j3cam55rj486n03wph81ynq1ps";

     

       45
       45
       +
           };

     

       46
       46
       +
           "bert-wiki.json" = fetchurl {

     

       47
       47
       +
             url = "https://s3.amazonaws.com/models.huggingface.co/bert/anthony/doc-pipeline/tokenizer.json";

     

       48
       48
       +
             hash = "sha256-i533xC8J5CDMNxBjo+p6avIM8UOcui8RmGAmK0GmfBc=";

     

       49
       49
       +
           };

     

       50
       50
       +
           "tokenizer-wiki.json" = fetchurl {

     

       51
       51
       +
             url = "https://s3.amazonaws.com/models.huggingface.co/bert/anthony/doc-quicktour/tokenizer.json";

     

       52
       52
       +
             hash = "sha256-ipY9d5DR5nxoO6kj7rItueZ9AO5wq9+Nzr6GuEIfIBI=";

     

       53
       53
       +
           };

     

       54
       54
       +
           "openai-gpt-vocab.json" = fetchurl {

     

       55
       55
       +
             url = "https://s3.amazonaws.com/models.huggingface.co/bert/openai-gpt-vocab.json";

     

       56
       56
       +
             sha256 = "0y40gc9bixj5rxv674br1rxmxkd3ly29p80x1596h8yywwcrpx7x";

     

       57
       57
       +
           };

     

       58
       58
       +
           "openai-gpt-merges.txt" = fetchurl {

     

       59
       59
       +
             url = "https://s3.amazonaws.com/models.huggingface.co/bert/openai-gpt-merges.txt";

     

       60
       60
       +
             sha256 = "09a754pm4djjglv3x5pkgwd6f79i2rq8ydg0f7c3q1wmwqdbba8f";

     

       61
       61
       +
           };

     

       59
       62
        
         };

     

       60
       63
        
       in

     

       61
       64
        
       buildPythonPackage rec {

     
···

       107
       110
        
         postUnpack = ''

     

       108
       111
        
           # Add data files for tests, otherwise tests attempt network access

     

       109
       112
        
           mkdir $sourceRoot/tests/data

     

       110
       110
       -
           ( cd $sourceRoot/tests/data

     

       111
       111
       -
             ln -s ${robertaVocab} roberta-base-vocab.json

     

       112
       112
       -
             ln -s ${robertaMerges} roberta-base-merges.txt

     

       113
       113
       -
             ln -s ${albertVocab} albert-base-v1-tokenizer.json

     

       114
       114
       -
             ln -s ${bertVocab} bert-base-uncased-vocab.txt

     

       115
       115
       -
             ln -s ${docPipelineTokenizer} bert-wiki.json

     

       116
       116
       -
             ln -s ${docQuicktourTokenizer} tokenizer-wiki.json

     

       117
       117
       -
             ln -s ${norvigBig} big.txt

     

       118
       118
       -
             ln -s ${openaiVocab} openai-gpt-vocab.json

     

       119
       119
       -
             ln -s ${openaiMerges} openai-gpt-merges.txt )

     

       113
       113
       +
           ln -s ${test-data}/* $sourceRoot/tests/data/

     

       120
       114
        
         '';

     

       121
       115
        
       

     

       122
       116
        
         preCheck = ''

+1 -1

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

···

       68
       68
        
           jinja2

     

       69
       69
        
           networkx

     

       70
       70
        
           filelock

     

       71
       71
       -
         ] ++ lib.optionals stdenv.isx86_64 [

     

       71
       71
       +
         ] ++ lib.optionals (stdenv.isLinux && stdenv.isx86_64) [

     

       72
       72
        
           openai-triton

     

       73
       73
        
         ];

     

       74
       74

+3 -3

pkgs/development/tools/bearer/default.nix

···

       7
       7
        
       

     

       8
       8
        
       buildGoModule rec {

     

       9
       9
        
         pname = "bearer";

     

       10
       10
       -
         version = "1.33.1";

     

       10
       10
       +
         version = "1.34.0";

     

       11
       11
        
       

     

       12
       12
        
         src = fetchFromGitHub {

     

       13
       13
        
           owner = "bearer";

     

       14
       14
        
           repo = "bearer";

     

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

     

       16
       16
       -
           hash = "sha256-cdD4LYQZwkS5dRhmvyHkio7TXPDgfDo7kutVAGJCitc=";

     

       16
       16
       +
           hash = "sha256-JNYjBcuA2KDdhd1yF0E7mEhNJ7xQRT+wFlnAnal/P9I=";

     

       17
       17
        
         };

     

       18
       18
        
       

     

       19
       19
       -
         vendorHash = "sha256-nh2hkwscb4EYEfumBXPFrLgxIxRlkVqBCnQZ4eMZbgg=";

     

       19
       19
       +
         vendorHash = "sha256-DykY1PFKsJ++F8ToAhyss5nAmsTOfXQXJpSo21oEhYc=";

     

       20
       20
        
       

     

       21
       21
        
         subPackages = [

     

       22
       22
        
           "cmd/bearer"

+4 -4

pkgs/os-specific/linux/kernel/kernels-org.json

···

       20
       20
        
               "hash": "sha256:0ns8qxcrxj9i76b93xcghl002l8vbkg7ksd435sikig62qr62gf4"

     

       21
       21
        
           },

     

       22
       22
        
           "5.4": {

     

       23
       23
       -
               "version": "5.4.265",

     

       24
       24
       -
               "hash": "sha256:05cvvwjiznn7hfd02qklklalg0chahvh5v18w64lcva6kzj9kbjd"

     

       23
       23
       +
               "version": "5.4.266",

     

       24
       24
       +
               "hash": "sha256:1dmcn9i3nvf1gldm1a32gnl5ybwbk2lizb3wa4gc06g7dxz2y1ys"

     

       25
       25
        
           },

     

       26
       26
        
           "4.19": {

     

       27
       27
       -
               "version": "4.19.303",

     

       28
       28
       -
               "hash": "sha256:0dlbl47xs7z4yf9cxbxqzd7zs1f9070jr6ck231wgppa6lwwwb82"

     

       27
       27
       +
               "version": "4.19.304",

     

       28
       28
       +
               "hash": "sha256:165mljr8v1cf4vf4a4b44hx089rprkssvi2azq5wbxxg3basbind"

     

       29
       29
        
           },

     

       30
       30
        
           "6.6": {

     

       31
       31
        
               "version": "6.6.10",

+2 -2

pkgs/os-specific/linux/kernel/linux-libre.nix

···

       1
       1
        
       { stdenv, lib, fetchsvn, linux

     

       2
       2
        
       , scripts ? fetchsvn {

     

       3
       3
        
           url = "https://www.fsfla.org/svn/fsfla/software/linux-libre/releases/branches/";

     

       4
       4
       -
           rev = "19459";

     

       5
       5
       -
           sha256 = "12qx165i6dp9mrsbmizw6ynyxwvq11dmwz00xgy5qgr4ag3y4z4c";

     

       4
       4
       +
           rev = "19473";

     

       5
       5
       +
           sha256 = "0k9pgjg6k9j00x4m3g6chnhgznr5r1yyqd9x8q7a9q9j88vygszs";

     

       6
       6
        
         }

     

       7
       7
        
       , ...

     

       8
       8
        
       }:

+2 -2

pkgs/servers/keycloak/default.nix

···

       18
       18
        
         '';

     

       19
       19
        
       in stdenv.mkDerivation rec {

     

       20
       20
        
         pname = "keycloak";

     

       21
       21
       -
         version = "23.0.3";

     

       21
       21
       +
         version = "23.0.4";

     

       22
       22
        
       

     

       23
       23
        
         src = fetchzip {

     

       24
       24
        
           url = "https://github.com/keycloak/keycloak/releases/download/${version}/keycloak-${version}.zip";

     

       25
       25
       -
           hash = "sha256-5K8+pfn1zoXzBWJevZBx+9kZmefs1AvPoshOKP/dkNY=";

     

       25
       25
       +
           hash = "sha256-qvgYH/e+V++Tk39sgELTiUqyoEbBuUoCRNaCiM8ZuoA=";

     

       26
       26
        
         };

     

       27
       27
        
       

     

       28
       28
        
         nativeBuildInputs = [ makeWrapper jre ];

+1 -1

pkgs/servers/keycloak/keycloak-metrics-spi/default.nix

···

       11
       11
        
           hash = "sha256-pacmx5w1VVWz3HmHO6sc2friNUpzo4zyJI1/TQgCXlc=";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
       -
         mvnHash = "sha256-rwAc2KtKo4vJ0JWwPquMyt+FHVNTmMpzBPbo8lWDN/A=";

     

       14
       14
       +
         mvnHash = "sha256-RjERY434UL9z/gNZFV+wMTITCmTPGanwu61L8sEGaKY=";

     

       15
       15
        
       

     

       16
       16
        
         installPhase = ''

     

       17
       17
        
           runHook preInstall

+3 -3

pkgs/servers/monitoring/telegraf/default.nix

···

       8
       8
        
       

     

       9
       9
        
       buildGoModule rec {

     

       10
       10
        
         pname = "telegraf";

     

       11
       11
       -
         version = "1.29.1";

     

       11
       11
       +
         version = "1.29.2";

     

       12
       12
        
       

     

       13
       13
        
         subPackages = [ "cmd/telegraf" ];

     

       14
       14
        
       

     
···

       16
       16
        
           owner = "influxdata";

     

       17
       17
        
           repo = "telegraf";

     

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

     

       19
       19
       -
           hash = "sha256-iEVVMARdt3gibahxU9snwo13yi6gINWWdhFkTHLYAuU=";

     

       19
       19
       +
           hash = "sha256-Z2+G4H1O4e77V9jfW+REK4PGdJgoPz+JgLxX/WqBoaY=";

     

       20
       20
        
         };

     

       21
       21
        
       

     

       22
       22
       -
         vendorHash = "sha256-R6+GKyGD7tUulOA6qEPUlSMj2/zXdLmmrX1HubLNCEc=";

     

       22
       22
       +
         vendorHash = "sha256-mPw3KfQy9DRqv8E6zzYAbeUaLaNfiNPU77ic+JqqBuM=";

     

       23
       23
        
         proxyVendor = true;

     

       24
       24
        
       

     

       25
       25
        
         ldflags = [

+2 -2

pkgs/test/checkpointBuild/default.nix

···

       10
       10
        
             patch -p1 < ${./hello.patch}

     

       11
       11
        
           '';

     

       12
       12
        
         });

     

       13
       13
       -
         checkpointBuiltHello = checkpointBuildTools.mkCheckpointedBuild patchedHello baseHelloArtifacts;

     

       13
       13
       +
         checkpointBuiltHello = checkpointBuildTools.mkCheckpointBuild patchedHello baseHelloArtifacts;

     

       14
       14
        
       

     

       15
       15
        
         checkpointBuiltHelloWithCheck = checkpointBuiltHello.overrideAttrs (old: {

     

       16
       16
        
           doCheck = true;

     
···

       41
       41
        
           '';

     

       42
       42
        
         });

     

       43
       43
        
       

     

       44
       44
       -
         checkpointBuiltHelloWithRemovedFile = checkpointBuildTools.mkCheckpointedBuild patchedHelloRemoveFile baseHelloRemoveFileArtifacts;

     

       44
       44
       +
         checkpointBuiltHelloWithRemovedFile = checkpointBuildTools.mkCheckpointBuild patchedHelloRemoveFile baseHelloRemoveFileArtifacts;

     

       45
       45
        
       in

     

       46
       46
        
       stdenv.mkDerivation {

     

       47
       47
        
         name = "patched-hello-returns-correct-output";

+1 -1

pkgs/test/default.nix

···

       113
       113
        
       

     

       114
       114
        
         install-shell-files = callPackage ./install-shell-files {};

     

       115
       115
        
       

     

       116
       116
       -
         checkpoint-build = callPackage ./checkpointBuild {};

     

       116
       116
       +
         checkpointBuildTools = callPackage ./checkpointBuild {};

     

       117
       117
        
       

     

       118
       118
        
         kernel-config = callPackage ./kernel.nix {};

     

       119
       119

+2

pkgs/test/nixpkgs-check-by-name/README.md

···

       28
       28
        
       - Each package directory must not refer to files outside itself using symlinks or Nix path expressions.

     

       29
       29
        
       

     

       30
       30
        
       ### Nix evaluation checks

     

       31
       31
       +
       

     

       32
       32
       +
       Evaluate Nixpkgs with `system` set to `x86_64-linux` and check that:

     

       31
       33
        
       - For each package directory, the `pkgs.${name}` attribute must be defined as `callPackage pkgs/by-name/${shard}/${name}/package.nix args` for some `args`.

     

       32
       34
        
       - For each package directory, `pkgs.lib.isDerivation pkgs.${name}` must be `true`.

     

       33
       35

+67 -56

pkgs/test/nixpkgs-check-by-name/src/eval.nix

···

       1
       1
        
       # Takes a path to nixpkgs and a path to the json-encoded list of attributes to check.

     

       2
       2
       -
       # Returns an attribute set containing information on each requested attribute.

     

       3
       3
       -
       # If the attribute is missing from Nixpkgs it's also missing from the result.

     

       4
       4
       -
       #

     

       5
       5
       -
       # The returned information is an attribute set with:

     

       6
       6
       -
       # - call_package_path: The <path> from `<attr> = callPackage <path> { ... }`,

     

       7
       7
       -
       #   or null if it's not defined as with callPackage, or if the <path> is not a path

     

       8
       8
       -
       # - is_derivation: The result of `lib.isDerivation <attr>`

     

       2
       2
       +
       # Returns an value containing information on each requested attribute,

     

       3
       3
       +
       # which is decoded on the Rust side.

     

       4
       4
       +
       # See ./eval.rs for the meaning of the returned values

     

       9
       5
        
       {

     

       10
       6
        
         attrsPath,

     

       11
       7
        
         nixpkgsPath,

     
···

       13
       9
        
       let

     

       14
       10
        
         attrs = builtins.fromJSON (builtins.readFile attrsPath);

     

       15
       11
        
       

     

       16
       16
       -
         # This overlay mocks callPackage to persist the path of the first argument

     

       17
       17
       -
         callPackageOverlay = self: super: {

     

       12
       12
       +
         nixpkgsPathLength = builtins.stringLength (toString nixpkgsPath) + 1;

     

       13
       13
       +
         removeNixpkgsPrefix = builtins.substring nixpkgsPathLength (-1);

     

       14
       14
       +
       

     

       15
       15
       +
         # We need access to the `callPackage` arguments of each attribute.

     

       16
       16
       +
         # The only way to do so is to override `callPackage` with our own version that adds this information to the result,

     

       17
       17
       +
         # and then try to access this information.

     

       18
       18
       +
         overlay = final: prev: {

     

       19
       19
       +
       

     

       20
       20
       +
           # Information for attributes defined using `callPackage`

     

       18
       21
        
           callPackage = fn: args:

     

       19
       19
       -
             let

     

       20
       20
       -
               result = super.callPackage fn args;

     

       21
       21
       -
               variantInfo._attributeVariant = {

     

       22
       22
       -
                 # These names are used by the deserializer on the Rust side

     

       23
       23
       -
                 CallPackage.path =

     

       22
       22
       +
             addVariantInfo (prev.callPackage fn args) {

     

       23
       23
       +
               Manual = {

     

       24
       24
       +
                 path =

     

       24
       25
        
                   if builtins.isPath fn then

     

       25
       25
       -
                     toString fn

     

       26
       26
       +
                     removeNixpkgsPrefix (toString fn)

     

       26
       27
        
                   else

     

       27
       28
        
                     null;

     

       28
       28
       -
                 CallPackage.empty_arg =

     

       29
       29
       +
                 empty_arg =

     

       29
       30
        
                   args == { };

     

       30
       31
        
               };

     

       31
       31
       -
             in

     

       32
       32
       -
             if builtins.isAttrs result then

     

       33
       33
       -
               # If this was the last overlay to be applied, we could just only return the `_callPackagePath`,

     

       34
       34
       -
               # but that's not the case because stdenv has another overlays on top of user-provided ones.

     

       35
       35
       -
               # So to not break the stdenv build we need to return the mostly proper result here

     

       36
       36
       -
               result // variantInfo

     

       37
       37
       -
             else

     

       38
       38
       -
               # It's very rare that callPackage doesn't return an attribute set, but it can occur.

     

       39
       39
       -
               variantInfo;

     

       32
       32
       +
             };

     

       40
       33
        
       

     

       34
       34
       +
           # Information for attributes that are auto-called from pkgs/by-name.

     

       35
       35
       +
           # This internal attribute is only used by pkgs/by-name

     

       41
       36
        
           _internalCallByNamePackageFile = file:

     

       42
       42
       -
             let

     

       43
       43
       -
               result = super._internalCallByNamePackageFile file;

     

       44
       44
       -
               variantInfo._attributeVariant = {

     

       45
       45
       -
                 # This name is used by the deserializer on the Rust side

     

       46
       46
       -
                 AutoCalled = null;

     

       47
       47
       -
               };

     

       48
       48
       -
             in

     

       49
       49
       -
             if builtins.isAttrs result then

     

       50
       50
       -
               # If this was the last overlay to be applied, we could just only return the `_callPackagePath`,

     

       51
       51
       -
               # but that's not the case because stdenv has another overlays on top of user-provided ones.

     

       52
       52
       -
               # So to not break the stdenv build we need to return the mostly proper result here

     

       53
       53
       -
               result // variantInfo

     

       54
       54
       -
             else

     

       55
       55
       -
               # It's very rare that callPackage doesn't return an attribute set, but it can occur.

     

       56
       56
       -
               variantInfo;

     

       37
       37
       +
             addVariantInfo (prev._internalCallByNamePackageFile file) {

     

       38
       38
       +
               Auto = null;

     

       39
       39
       +
             };

     

       40
       40
       +
       

     

       57
       41
        
         };

     

       58
       42
        
       

     

       43
       43
       +
         # We can't just replace attribute values with their info in the overlay,

     

       44
       44
       +
         # because attributes can depend on other attributes, so this would break evaluation.

     

       45
       45
       +
         addVariantInfo = value: variant:

     

       46
       46
       +
           if builtins.isAttrs value then

     

       47
       47
       +
             value // {

     

       48
       48
       +
               _callPackageVariant = variant;

     

       49
       49
       +
             }

     

       50
       50
       +
           else

     

       51
       51
       +
             # It's very rare that callPackage doesn't return an attribute set, but it can occur.

     

       52
       52
       +
             # In such a case we can't really return anything sensible that would include the info,

     

       53
       53
       +
             # so just don't return the info and let the consumer handle it.

     

       54
       54
       +
             value;

     

       55
       55
       +
       

     

       59
       56
        
         pkgs = import nixpkgsPath {

     

       60
       57
        
           # Don't let the users home directory influence this result

     

       61
       58
        
           config = { };

     

       62
       62
       -
           overlays = [ callPackageOverlay ];

     

       59
       59
       +
           overlays = [ overlay ];

     

       60
       60
       +
           # We check evaluation and callPackage only for x86_64-linux.

     

       61
       61
       +
           # Not ideal, but hard to fix

     

       62
       62
       +
           system = "x86_64-linux";

     

       63
       63
        
         };

     

       64
       64
        
       

     

       65
       65
       -
         attrInfo = attr:

     

       66
       66
       -
           let

     

       67
       67
       -
             value = pkgs.${attr};

     

       68
       68
       -
           in

     

       69
       69
       -
           {

     

       70
       70
       -
           # These names are used by the deserializer on the Rust side

     

       71
       71
       -
           variant = value._attributeVariant or { Other = null; };

     

       72
       72
       -
           is_derivation = pkgs.lib.isDerivation value;

     

       73
       73
       -
         };

     

       65
       65
       +
         attrInfo = name: value:

     

       66
       66
       +
           if ! builtins.isAttrs value then

     

       67
       67
       +
             {

     

       68
       68
       +
               NonAttributeSet = null;

     

       69
       69
       +
             }

     

       70
       70
       +
           else if ! value ? _callPackageVariant then

     

       71
       71
       +
             {

     

       72
       72
       +
               NonCallPackage = null;

     

       73
       73
       +
             }

     

       74
       74
       +
           else

     

       75
       75
       +
             {

     

       76
       76
       +
               CallPackage = {

     

       77
       77
       +
                 call_package_variant = value._callPackageVariant;

     

       78
       78
       +
                 is_derivation = pkgs.lib.isDerivation value;

     

       79
       79
       +
               };

     

       80
       80
       +
             };

     

       74
       81
        
       

     

       75
       75
       -
         attrInfos = builtins.listToAttrs (map (name: {

     

       76
       76
       -
           inherit name;

     

       77
       77
       -
           value = attrInfo name;

     

       78
       78
       -
         }) attrs);

     

       82
       82
       +
         attrInfos = map (name: [

     

       83
       83
       +
           name

     

       84
       84
       +
           (

     

       85
       85
       +
             if ! pkgs ? ${name} then

     

       86
       86
       +
               { Missing = null; }

     

       87
       87
       +
             else

     

       88
       88
       +
               { Existing = attrInfo name pkgs.${name}; }

     

       89
       89
       +
           )

     

       90
       90
       +
         ]) attrs;

     

       79
       91
        
       

     

       80
       92
        
       in

     

       81
       81
       -
       # Filter out attributes not in Nixpkgs

     

       82
       82
       -
       builtins.intersectAttrs pkgs attrInfos

     

       93
       93
       +
       attrInfos

+111 -78

pkgs/test/nixpkgs-check-by-name/src/eval.rs

···

       6
       6
        
       

     

       7
       7
        
       use anyhow::Context;

     

       8
       8
        
       use serde::Deserialize;

     

       9
       9
       -
       use std::collections::HashMap;

     

       10
       9
        
       use std::path::PathBuf;

     

       11
       10
        
       use std::process;

     

       12
       11
        
       use tempfile::NamedTempFile;

     

       13
       12
        
       

     

       14
       13
        
       /// Attribute set of this structure is returned by eval.nix

     

       15
       14
        
       #[derive(Deserialize)]

     

       16
       16
       -
       struct AttributeInfo {

     

       17
       17
       -
           variant: AttributeVariant,

     

       15
       15
       +
       enum ByNameAttribute {

     

       16
       16
       +
           /// The attribute doesn't exist at all

     

       17
       17
       +
           Missing,

     

       18
       18
       +
           Existing(AttributeInfo),

     

       19
       19
       +
       }

     

       20
       20
       +
       

     

       21
       21
       +
       #[derive(Deserialize)]

     

       22
       22
       +
       enum AttributeInfo {

     

       23
       23
       +
           /// The attribute exists, but its value isn't an attribute set

     

       24
       24
       +
           NonAttributeSet,

     

       25
       25
       +
           /// The attribute exists, but its value isn't defined using callPackage

     

       26
       26
       +
           NonCallPackage,

     

       27
       27
       +
           /// The attribute exists and its value is an attribute set

     

       28
       28
       +
           CallPackage(CallPackageInfo),

     

       29
       29
       +
       }

     

       30
       30
       +
       

     

       31
       31
       +
       #[derive(Deserialize)]

     

       32
       32
       +
       struct CallPackageInfo {

     

       33
       33
       +
           call_package_variant: CallPackageVariant,

     

       34
       34
       +
           /// Whether the attribute is a derivation (`lib.isDerivation`)

     

       18
       35
        
           is_derivation: bool,

     

       19
       36
        
       }

     

       20
       37
        
       

     

       21
       38
        
       #[derive(Deserialize)]

     

       22
       22
       -
       enum AttributeVariant {

     

       39
       39
       +
       enum CallPackageVariant {

     

       23
       40
        
           /// The attribute is auto-called as pkgs.callPackage using pkgs/by-name,

     

       24
       41
        
           /// and it is not overridden by a definition in all-packages.nix

     

       25
       25
       -
           AutoCalled,

     

       42
       42
       +
           Auto,

     

       26
       43
        
           /// The attribute is defined as a pkgs.callPackage <path> <args>,

     

       27
       44
        
           /// and overridden by all-packages.nix

     

       28
       28
       -
           CallPackage {

     

       45
       45
       +
           Manual {

     

       29
       46
        
               /// The <path> argument or None if it's not a path

     

       30
       47
        
               path: Option<PathBuf>,

     

       31
       48
        
               /// true if <args> is { }

     

       32
       49
        
               empty_arg: bool,

     

       33
       50
        
           },

     

       34
       34
       -
           /// The attribute is not defined as pkgs.callPackage

     

       35
       35
       -
           Other,

     

       36
       51
        
       }

     

       37
       52
        
       

     

       38
       53
        
       /// Check that the Nixpkgs attribute values corresponding to the packages in pkgs/by-name are

     
···

       45
       60
        
       ) -> validation::Result<ratchet::Nixpkgs> {

     

       46
       61
        
           // Write the list of packages we need to check into a temporary JSON file.

     

       47
       62
        
           // This can then get read by the Nix evaluation.

     

       48
       48
       -
           let attrs_file = NamedTempFile::new().context("Failed to create a temporary file")?;

     

       63
       63
       +
           let attrs_file = NamedTempFile::new().with_context(|| "Failed to create a temporary file")?;

     

       49
       64
        
           // We need to canonicalise this path because if it's a symlink (which can be the case on

     

       50
       65
        
           // Darwin), Nix would need to read both the symlink and the target path, therefore need 2

     

       51
       66
        
           // NIX_PATH entries for restrict-eval. But if we resolve the symlinks then only one predictable

     

       52
       67
        
           // entry is needed.

     

       53
       68
        
           let attrs_file_path = attrs_file.path().canonicalize()?;

     

       54
       69
        
       

     

       55
       55
       -
           serde_json::to_writer(&attrs_file, &package_names).context(format!(

     

       56
       56
       -
               "Failed to serialise the package names to the temporary path {}",

     

       57
       57
       -
               attrs_file_path.display()

     

       58
       58
       -
           ))?;

     

       70
       70
       +
           serde_json::to_writer(&attrs_file, &package_names).with_context(|| {

     

       71
       71
       +
               format!(

     

       72
       72
       +
                   "Failed to serialise the package names to the temporary path {}",

     

       73
       73
       +
                   attrs_file_path.display()

     

       74
       74
       +
               )

     

       75
       75
       +
           })?;

     

       59
       76
        
       

     

       60
       77
        
           let expr_path = std::env::var("NIX_CHECK_BY_NAME_EXPR_PATH")

     

       61
       61
       -
               .context("Could not get environment variable NIX_CHECK_BY_NAME_EXPR_PATH")?;

     

       78
       78
       +
               .with_context(|| "Could not get environment variable NIX_CHECK_BY_NAME_EXPR_PATH")?;

     

       62
       79
        
           // With restrict-eval, only paths in NIX_PATH can be accessed, so we explicitly specify the

     

       63
       80
        
           // ones needed needed

     

       64
       81
        
           let mut command = process::Command::new("nix-instantiate");

     
···

       97
       114
        
       

     

       98
       115
        
           let result = command

     

       99
       116
        
               .output()

     

       100
       100
       -
               .context(format!("Failed to run command {command:?}"))?;

     

       117
       117
       +
               .with_context(|| format!("Failed to run command {command:?}"))?;

     

       101
       118
        
       

     

       102
       119
        
           if !result.status.success() {

     

       103
       120
        
               anyhow::bail!("Failed to run command {command:?}");

     

       104
       121
        
           }

     

       105
       122
        
           // Parse the resulting JSON value

     

       106
       106
       -
           let actual_files: HashMap<String, AttributeInfo> = serde_json::from_slice(&result.stdout)

     

       107
       107
       -
               .context(format!(

     

       108
       108
       -
                   "Failed to deserialise {}",

     

       109
       109
       -
                   String::from_utf8_lossy(&result.stdout)

     

       110
       110
       -
               ))?;

     

       123
       123
       +
           let attributes: Vec<(String, ByNameAttribute)> = serde_json::from_slice(&result.stdout)

     

       124
       124
       +
               .with_context(|| {

     

       125
       125
       +
                   format!(

     

       126
       126
       +
                       "Failed to deserialise {}",

     

       127
       127
       +
                       String::from_utf8_lossy(&result.stdout)

     

       128
       128
       +
                   )

     

       129
       129
       +
               })?;

     

       111
       130
        
       

     

       112
       112
       -
           Ok(

     

       113
       113
       -
               validation::sequence(package_names.into_iter().map(|package_name| {

     

       114
       114
       -
                   let relative_package_file = structure::relative_file_for_package(&package_name);

     

       115
       115
       -
                   let absolute_package_file = nixpkgs_path.join(&relative_package_file);

     

       131
       131
       +
           let check_result = validation::sequence(attributes.into_iter().map(

     

       132
       132
       +
               |(attribute_name, attribute_value)| {

     

       133
       133
       +
                   let relative_package_file = structure::relative_file_for_package(&attribute_name);

     

       116
       134
        
       

     

       117
       117
       -
                   if let Some(attribute_info) = actual_files.get(&package_name) {

     

       118
       118
       -
                       let check_result = if !attribute_info.is_derivation {

     

       119
       119
       -
                           NixpkgsProblem::NonDerivation {

     

       120
       120
       -
                               relative_package_file: relative_package_file.clone(),

     

       121
       121
       -
                               package_name: package_name.clone(),

     

       122
       122
       -
                           }

     

       123
       123
       -
                           .into()

     

       124
       124
       -
                       } else {

     

       125
       125
       -
                           Success(())

     

       126
       126
       -
                       };

     

       135
       135
       +
                   use ratchet::RatchetState::*;

     

       136
       136
       +
                   use AttributeInfo::*;

     

       137
       137
       +
                   use ByNameAttribute::*;

     

       138
       138
       +
                   use CallPackageVariant::*;

     

       139
       139
       +
       

     

       140
       140
       +
                   let check_result = match attribute_value {

     

       141
       141
       +
                       Missing => NixpkgsProblem::UndefinedAttr {

     

       142
       142
       +
                           relative_package_file: relative_package_file.clone(),

     

       143
       143
       +
                           package_name: attribute_name.clone(),

     

       144
       144
       +
                       }

     

       145
       145
       +
                       .into(),

     

       146
       146
       +
                       Existing(NonAttributeSet) => NixpkgsProblem::NonDerivation {

     

       147
       147
       +
                           relative_package_file: relative_package_file.clone(),

     

       148
       148
       +
                           package_name: attribute_name.clone(),

     

       149
       149
       +
                       }

     

       150
       150
       +
                       .into(),

     

       151
       151
       +
                       Existing(NonCallPackage) => NixpkgsProblem::WrongCallPackage {

     

       152
       152
       +
                           relative_package_file: relative_package_file.clone(),

     

       153
       153
       +
                           package_name: attribute_name.clone(),

     

       154
       154
       +
                       }

     

       155
       155
       +
                       .into(),

     

       156
       156
       +
                       Existing(CallPackage(CallPackageInfo {

     

       157
       157
       +
                           is_derivation,

     

       158
       158
       +
                           call_package_variant,

     

       159
       159
       +
                       })) => {

     

       160
       160
       +
                           let check_result = if !is_derivation {

     

       161
       161
       +
                               NixpkgsProblem::NonDerivation {

     

       162
       162
       +
                                   relative_package_file: relative_package_file.clone(),

     

       163
       163
       +
                                   package_name: attribute_name.clone(),

     

       164
       164
       +
                               }

     

       165
       165
       +
                               .into()

     

       166
       166
       +
                           } else {

     

       167
       167
       +
                               Success(())

     

       168
       168
       +
                           };

     

       127
       169
        
       

     

       128
       128
       -
                       let check_result = check_result.and(match &attribute_info.variant {

     

       129
       129
       -
                           AttributeVariant::AutoCalled => Success(ratchet::Package {

     

       130
       130
       -
                               empty_non_auto_called: ratchet::EmptyNonAutoCalled::Valid,

     

       131
       131
       -
                           }),

     

       132
       132
       -
                           AttributeVariant::CallPackage { path, empty_arg } => {

     

       133
       133
       -
                               let correct_file = if let Some(call_package_path) = path {

     

       134
       134
       -
                                   absolute_package_file == *call_package_path

     

       135
       135
       -
                               } else {

     

       136
       136
       -
                                   false

     

       137
       137
       -
                               };

     

       170
       170
       +
                           check_result.and(match &call_package_variant {

     

       171
       171
       +
                               Auto => Success(ratchet::Package {

     

       172
       172
       +
                                   empty_non_auto_called: Tight,

     

       173
       173
       +
                               }),

     

       174
       174
       +
                               Manual { path, empty_arg } => {

     

       175
       175
       +
                                   let correct_file = if let Some(call_package_path) = path {

     

       176
       176
       +
                                       relative_package_file == *call_package_path

     

       177
       177
       +
                                   } else {

     

       178
       178
       +
                                       false

     

       179
       179
       +
                                   };

     

       138
       180
        
       

     

       139
       139
       -
                               if correct_file {

     

       140
       140
       -
                                   Success(ratchet::Package {

     

       141
       141
       -
                                       // Empty arguments for non-auto-called packages are not allowed anymore.

     

       142
       142
       -
                                       empty_non_auto_called: if *empty_arg {

     

       143
       143
       -
                                           ratchet::EmptyNonAutoCalled::Invalid

     

       144
       144
       -
                                       } else {

     

       145
       145
       -
                                           ratchet::EmptyNonAutoCalled::Valid

     

       146
       146
       -
                                       },

     

       147
       147
       -
                                   })

     

       148
       148
       -
                               } else {

     

       149
       149
       -
                                   NixpkgsProblem::WrongCallPackage {

     

       150
       150
       -
                                       relative_package_file: relative_package_file.clone(),

     

       151
       151
       -
                                       package_name: package_name.clone(),

     

       181
       181
       +
                                   if correct_file {

     

       182
       182
       +
                                       Success(ratchet::Package {

     

       183
       183
       +
                                           // Empty arguments for non-auto-called packages are not allowed anymore.

     

       184
       184
       +
                                           empty_non_auto_called: if *empty_arg {

     

       185
       185
       +
                                               Loose(ratchet::EmptyNonAutoCalled)

     

       186
       186
       +
                                           } else {

     

       187
       187
       +
                                               Tight

     

       188
       188
       +
                                           },

     

       189
       189
       +
                                       })

     

       190
       190
       +
                                   } else {

     

       191
       191
       +
                                       NixpkgsProblem::WrongCallPackage {

     

       192
       192
       +
                                           relative_package_file: relative_package_file.clone(),

     

       193
       193
       +
                                           package_name: attribute_name.clone(),

     

       194
       194
       +
                                       }

     

       195
       195
       +
                                       .into()

     

       152
       196
        
                                   }

     

       153
       153
       -
                                   .into()

     

       154
       197
        
                               }

     

       155
       155
       -
                           }

     

       156
       156
       -
                           AttributeVariant::Other => NixpkgsProblem::WrongCallPackage {

     

       157
       157
       -
                               relative_package_file: relative_package_file.clone(),

     

       158
       158
       -
                               package_name: package_name.clone(),

     

       159
       159
       -
                           }

     

       160
       160
       -
                           .into(),

     

       161
       161
       -
                       });

     

       198
       198
       +
                           })

     

       199
       199
       +
                       }

     

       200
       200
       +
                   };

     

       201
       201
       +
                   check_result.map(|value| (attribute_name.clone(), value))

     

       202
       202
       +
               },

     

       203
       203
       +
           ));

     

       162
       204
        
       

     

       163
       163
       -
                       check_result.map(|value| (package_name.clone(), value))

     

       164
       164
       -
                   } else {

     

       165
       165
       -
                       NixpkgsProblem::UndefinedAttr {

     

       166
       166
       -
                           relative_package_file: relative_package_file.clone(),

     

       167
       167
       -
                           package_name: package_name.clone(),

     

       168
       168
       -
                       }

     

       169
       169
       -
                       .into()

     

       170
       170
       -
                   }

     

       171
       171
       -
               }))

     

       172
       172
       -
               .map(|elems| ratchet::Nixpkgs {

     

       173
       173
       -
                   packages: elems.into_iter().collect(),

     

       174
       174
       -
               }),

     

       175
       175
       -
           )

     

       205
       205
       +
           Ok(check_result.map(|elems| ratchet::Nixpkgs {

     

       206
       206
       +
               package_names,

     

       207
       207
       +
               package_map: elems.into_iter().collect(),

     

       208
       208
       +
           }))

     

       176
       209
        
       }

+20 -24

pkgs/test/nixpkgs-check-by-name/src/main.rs

···

       38
       38
        
       

     

       39
       39
        
           /// Path to the base Nixpkgs to run ratchet checks against.

     

       40
       40
        
           /// For PRs, this should be set to a checkout of the PRs base branch.

     

       41
       41
       -
           /// If not specified, no ratchet checks will be performed.

     

       42
       42
       -
           /// However, this flag will become required once CI uses it.

     

       43
       41
        
           #[arg(long)]

     

       44
       44
       -
           base: Option<PathBuf>,

     

       42
       42
       +
           base: PathBuf,

     

       45
       43
        
       }

     

       46
       44
        
       

     

       47
       45
        
       fn main() -> ExitCode {

     

       48
       46
        
           let args = Args::parse();

     

       49
       49
       -
           match process(args.base.as_deref(), &args.nixpkgs, &[], &mut io::stderr()) {

     

       47
       47
       +
           match process(&args.base, &args.nixpkgs, &[], &mut io::stderr()) {

     

       50
       48
        
               Ok(true) => {

     

       51
       49
        
                   eprintln!("{}", "Validated successfully".green());

     

       52
       50
        
                   ExitCode::SUCCESS

     
···

       77
       75
        
       /// - `Ok(false)` if there are problems, all of which will be written to `error_writer`.

     

       78
       76
        
       /// - `Ok(true)` if there are no problems

     

       79
       77
        
       pub fn process<W: io::Write>(

     

       80
       80
       -
           base_nixpkgs: Option<&Path>,

     

       78
       78
       +
           base_nixpkgs: &Path,

     

       81
       79
        
           main_nixpkgs: &Path,

     

       82
       80
        
           eval_accessible_paths: &[&Path],

     

       83
       81
        
           error_writer: &mut W,

     
···

       87
       85
        
           let check_result = main_result.result_map(|nixpkgs_version| {

     

       88
       86
        
               // If the main Nixpkgs doesn't have any problems, run the ratchet checks against the base

     

       89
       87
        
               // Nixpkgs

     

       90
       90
       -
               if let Some(base) = base_nixpkgs {

     

       91
       91
       -
                   check_nixpkgs(base, eval_accessible_paths, error_writer)?.result_map(

     

       92
       92
       -
                       |base_nixpkgs_version| {

     

       93
       93
       -
                           Ok(ratchet::Nixpkgs::compare(

     

       94
       94
       -
                               Some(base_nixpkgs_version),

     

       95
       95
       -
                               nixpkgs_version,

     

       96
       96
       -
                           ))

     

       97
       97
       -
                       },

     

       98
       98
       -
                   )

     

       99
       99
       -
               } else {

     

       100
       100
       -
                   Ok(ratchet::Nixpkgs::compare(None, nixpkgs_version))

     

       101
       101
       -
               }

     

       88
       88
       +
               check_nixpkgs(base_nixpkgs, eval_accessible_paths, error_writer)?.result_map(

     

       89
       89
       +
                   |base_nixpkgs_version| {

     

       90
       90
       +
                       Ok(ratchet::Nixpkgs::compare(

     

       91
       91
       +
                           base_nixpkgs_version,

     

       92
       92
       +
                           nixpkgs_version,

     

       93
       93
       +
                       ))

     

       94
       94
       +
                   },

     

       95
       95
       +
               )

     

       102
       96
        
           })?;

     

       103
       97
        
       

     

       104
       98
        
           match check_result {

     
···

       123
       117
        
           error_writer: &mut W,

     

       124
       118
        
       ) -> validation::Result<ratchet::Nixpkgs> {

     

       125
       119
        
           Ok({

     

       126
       126
       -
               let nixpkgs_path = nixpkgs_path.canonicalize().context(format!(

     

       127
       127
       -
                   "Nixpkgs path {} could not be resolved",

     

       128
       128
       -
                   nixpkgs_path.display()

     

       129
       129
       -
               ))?;

     

       120
       120
       +
               let nixpkgs_path = nixpkgs_path.canonicalize().with_context(|| {

     

       121
       121
       +
                   format!(

     

       122
       122
       +
                       "Nixpkgs path {} could not be resolved",

     

       123
       123
       +
                       nixpkgs_path.display()

     

       124
       124
       +
                   )

     

       125
       125
       +
               })?;

     

       130
       126
        
       

     

       131
       127
        
               if !nixpkgs_path.join(utils::BASE_SUBPATH).exists() {

     

       132
       128
        
                   writeln!(

     
···

       234
       230
        
       

     

       235
       231
        
               let base_path = path.join("base");

     

       236
       232
        
               let base_nixpkgs = if base_path.exists() {

     

       237
       237
       -
                   Some(base_path.as_path())

     

       233
       233
       +
                   base_path.as_path()

     

       238
       234
        
               } else {

     

       239
       239
       -
                   None

     

       235
       235
       +
                   Path::new("tests/empty-base")

     

       240
       236
        
               };

     

       241
       237
        
       

     

       242
       238
        
               // We don't want coloring to mess up the tests

     

       243
       239
        
               let writer = temp_env::with_var("NO_COLOR", Some("1"), || -> anyhow::Result<_> {

     

       244
       240
        
                   let mut writer = vec![];

     

       245
       241
        
                   process(base_nixpkgs, &path, &[&extra_nix_path], &mut writer)

     

       246
       246
       -
                       .context(format!("Failed test case {name}"))?;

     

       242
       242
       +
                       .with_context(|| format!("Failed test case {name}"))?;

     

       247
       243
        
                   Ok(writer)

     

       248
       244
        
               })?;

     

       249
       245

+57 -38

pkgs/test/nixpkgs-check-by-name/src/ratchet.rs

···

       10
       10
        
       /// The ratchet value for the entirety of Nixpkgs.

     

       11
       11
        
       #[derive(Default)]

     

       12
       12
        
       pub struct Nixpkgs {

     

       13
       13
       -
           /// The ratchet values for each package in `pkgs/by-name`

     

       14
       14
       -
           pub packages: HashMap<String, Package>,

     

       13
       13
       +
           /// Sorted list of attributes in package_map

     

       14
       14
       +
           pub package_names: Vec<String>,

     

       15
       15
       +
           /// The ratchet values for all packages

     

       16
       16
       +
           pub package_map: HashMap<String, Package>,

     

       15
       17
        
       }

     

       16
       18
        
       

     

       17
       19
        
       impl Nixpkgs {

     

       18
       20
        
           /// Validates the ratchet checks for Nixpkgs

     

       19
       19
       -
           pub fn compare(optional_from: Option<Self>, to: Self) -> Validation<()> {

     

       21
       21
       +
           pub fn compare(from: Self, to: Self) -> Validation<()> {

     

       20
       22
        
               validation::sequence_(

     

       21
       23
        
                   // We only loop over the current attributes,

     

       22
       24
        
                   // we don't need to check ones that were removed

     

       23
       23
       -
                   to.packages.into_iter().map(|(name, attr_to)| {

     

       24
       24
       -
                       let attr_from = if let Some(from) = &optional_from {

     

       25
       25
       -
                           from.packages.get(&name)

     

       26
       26
       -
                       } else {

     

       27
       27
       -
                           // This pretends that if there's no base version to compare against, all

     

       28
       28
       -
                           // attributes existed without conforming to the new strictness check for

     

       29
       29
       -
                           // backwards compatibility.

     

       30
       30
       -
                           // TODO: Remove this case. This is only needed because the `--base`

     

       31
       31
       -
                           // argument is still optional, which doesn't need to be once CI is updated

     

       32
       32
       -
                           // to pass it.

     

       33
       33
       -
                           Some(&Package {

     

       34
       34
       -
                               empty_non_auto_called: EmptyNonAutoCalled::Invalid,

     

       35
       35
       -
                           })

     

       36
       36
       -
                       };

     

       37
       37
       -
                       Package::compare(&name, attr_from, &attr_to)

     

       25
       25
       +
                   to.package_names.into_iter().map(|name| {

     

       26
       26
       +
                       Package::compare(&name, from.package_map.get(&name), &to.package_map[&name])

     

       38
       27
        
                   }),

     

       39
       28
        
               )

     

       40
       29
        
           }

     
···

       43
       32
        
       /// The ratchet value for a single package in `pkgs/by-name`

     

       44
       33
        
       pub struct Package {

     

       45
       34
        
           /// The ratchet value for the check for non-auto-called empty arguments

     

       46
       46
       -
           pub empty_non_auto_called: EmptyNonAutoCalled,

     

       35
       35
       +
           pub empty_non_auto_called: RatchetState<EmptyNonAutoCalled>,

     

       47
       36
        
       }

     

       48
       37
        
       

     

       49
       38
        
       impl Package {

     

       50
       39
        
           /// Validates the ratchet checks for a single package defined in `pkgs/by-name`

     

       51
       40
        
           pub fn compare(name: &str, optional_from: Option<&Self>, to: &Self) -> Validation<()> {

     

       52
       52
       -
               EmptyNonAutoCalled::compare(

     

       41
       41
       +
               RatchetState::<EmptyNonAutoCalled>::compare(

     

       53
       42
        
                   name,

     

       54
       43
        
                   optional_from.map(|x| &x.empty_non_auto_called),

     

       55
       44
        
                   &to.empty_non_auto_called,

     
···

       57
       46
        
           }

     

       58
       47
        
       }

     

       59
       48
        
       

     

       60
       60
       -
       /// The ratchet value of a single package in `pkgs/by-name`

     

       49
       49
       +
       /// The ratchet state of a generic ratchet check.

     

       50
       50
       +
       pub enum RatchetState<Context> {

     

       51
       51
       +
           /// The ratchet is loose, it can be tightened more.

     

       52
       52
       +
           /// In other words, this is the legacy state we're trying to move away from.

     

       53
       53
       +
           /// Introducing new instances is not allowed but previous instances will continue to be allowed.

     

       54
       54
       +
           /// The `Context` is context for error messages in case a new instance of this state is

     

       55
       55
       +
           /// introduced

     

       56
       56
       +
           Loose(Context),

     

       57
       57
       +
           /// The ratchet is tight, it can't be tightened any further.

     

       58
       58
       +
           /// This is either because we already use the latest state, or because the ratchet isn't

     

       59
       59
       +
           /// relevant.

     

       60
       60
       +
           Tight,

     

       61
       61
       +
       }

     

       62
       62
       +
       

     

       63
       63
       +
       /// A trait that can convert an attribute-specific error context into a NixpkgsProblem

     

       64
       64
       +
       pub trait ToNixpkgsProblem {

     

       65
       65
       +
           /// How to convert an attribute-specific error context into a NixpkgsProblem

     

       66
       66
       +
           fn to_nixpkgs_problem(name: &str, context: &Self, existed_before: bool) -> NixpkgsProblem;

     

       67
       67
       +
       }

     

       68
       68
       +
       

     

       69
       69
       +
       impl<Context: ToNixpkgsProblem> RatchetState<Context> {

     

       70
       70
       +
           /// Compare the previous ratchet state of an attribute to the new state.

     

       71
       71
       +
           /// The previous state may be `None` in case the attribute is new.

     

       72
       72
       +
           fn compare(name: &str, optional_from: Option<&Self>, to: &Self) -> Validation<()> {

     

       73
       73
       +
               // If we don't have a previous state, enforce a tight ratchet

     

       74
       74
       +
               let from = optional_from.unwrap_or(&RatchetState::Tight);

     

       75
       75
       +
               match (from, to) {

     

       76
       76
       +
                   // Always okay to keep it tight or tighten the ratchet

     

       77
       77
       +
                   (_, RatchetState::Tight) => Success(()),

     

       78
       78
       +
       

     

       79
       79
       +
                   // Grandfathering policy for a loose ratchet

     

       80
       80
       +
                   (RatchetState::Loose { .. }, RatchetState::Loose { .. }) => Success(()),

     

       81
       81
       +
       

     

       82
       82
       +
                   // Loosening a ratchet is now allowed

     

       83
       83
       +
                   (RatchetState::Tight, RatchetState::Loose(context)) => {

     

       84
       84
       +
                       Context::to_nixpkgs_problem(name, context, optional_from.is_some()).into()

     

       85
       85
       +
                   }

     

       86
       86
       +
               }

     

       87
       87
       +
           }

     

       88
       88
       +
       }

     

       89
       89
       +
       

     

       90
       90
       +
       /// The ratchet value of an attribute

     

       61
       91
        
       /// for the non-auto-called empty argument check of a single.

     

       62
       92
        
       ///

     

       63
       93
        
       /// This checks that packages defined in `pkgs/by-name` cannot be overridden

     

       64
       94
        
       /// with an empty second argument like `callPackage ... { }`.

     

       65
       65
       -
       #[derive(PartialEq, PartialOrd)]

     

       66
       66
       -
       pub enum EmptyNonAutoCalled {

     

       67
       67
       -
           Invalid,

     

       68
       68
       -
           Valid,

     

       69
       69
       -
       }

     

       95
       95
       +
       pub struct EmptyNonAutoCalled;

     

       70
       96
        
       

     

       71
       71
       -
       impl EmptyNonAutoCalled {

     

       72
       72
       -
           /// Validates the non-auto-called empty argument ratchet check for a single package defined in `pkgs/by-name`

     

       73
       73
       -
           fn compare(name: &str, optional_from: Option<&Self>, to: &Self) -> Validation<()> {

     

       74
       74
       -
               let from = optional_from.unwrap_or(&Self::Valid);

     

       75
       75
       -
               if to >= from {

     

       76
       76
       -
                   Success(())

     

       77
       77
       -
               } else {

     

       78
       78
       -
                   NixpkgsProblem::WrongCallPackage {

     

       79
       79
       -
                       relative_package_file: structure::relative_file_for_package(name),

     

       80
       80
       -
                       package_name: name.to_owned(),

     

       81
       81
       -
                   }

     

       82
       82
       -
                   .into()

     

       97
       97
       +
       impl ToNixpkgsProblem for EmptyNonAutoCalled {

     

       98
       98
       +
           fn to_nixpkgs_problem(name: &str, _context: &Self, _existed_before: bool) -> NixpkgsProblem {

     

       99
       99
       +
               NixpkgsProblem::WrongCallPackage {

     

       100
       100
       +
                   relative_package_file: structure::relative_file_for_package(name),

     

       101
       101
       +
                   package_name: name.to_owned(),

     

       83
       102
        
               }

     

       84
       103
        
           }

     

       85
       104
        
       }

+16 -13

pkgs/test/nixpkgs-check-by-name/src/references.rs

···

       17
       17
        
       ) -> validation::Result<()> {

     

       18
       18
        
           // The empty argument here is the subpath under the package directory to check

     

       19
       19
        
           // An empty one means the package directory itself

     

       20
       20
       -
           check_path(relative_package_dir, absolute_package_dir, Path::new("")).context(format!(

     

       21
       21
       -
               "While checking the references in package directory {}",

     

       22
       22
       -
               relative_package_dir.display()

     

       23
       23
       -
           ))

     

       20
       20
       +
           check_path(relative_package_dir, absolute_package_dir, Path::new("")).with_context(|| {

     

       21
       21
       +
               format!(

     

       22
       22
       +
                   "While checking the references in package directory {}",

     

       23
       23
       +
                   relative_package_dir.display()

     

       24
       24
       +
               )

     

       25
       25
       +
           })

     

       24
       26
        
       }

     

       25
       27
        
       

     

       26
       28
        
       /// Checks for a specific path to not have references outside

     
···

       62
       64
        
                       .map(|entry| {

     

       63
       65
        
                           let entry_subpath = subpath.join(entry.file_name());

     

       64
       66
        
                           check_path(relative_package_dir, absolute_package_dir, &entry_subpath)

     

       65
       65
       -
                               .context(format!("Error while recursing into {}", subpath.display()))

     

       67
       67
       +
                               .with_context(|| {

     

       68
       68
       +
                                   format!("Error while recursing into {}", subpath.display())

     

       69
       69
       +
                               })

     

       66
       70
        
                       })

     

       67
       71
        
                       .collect_vec()?,

     

       68
       72
        
               )

     
···

       70
       74
        
               // Only check Nix files

     

       71
       75
        
               if let Some(ext) = path.extension() {

     

       72
       76
        
                   if ext == OsStr::new("nix") {

     

       73
       73
       -
                       check_nix_file(relative_package_dir, absolute_package_dir, subpath).context(

     

       74
       74
       -
                           format!("Error while checking Nix file {}", subpath.display()),

     

       77
       77
       +
                       check_nix_file(relative_package_dir, absolute_package_dir, subpath).with_context(

     

       78
       78
       +
                           || format!("Error while checking Nix file {}", subpath.display()),

     

       75
       79
        
                       )?

     

       76
       80
        
                   } else {

     

       77
       81
        
                       Success(())

     
···

       93
       97
        
           subpath: &Path,

     

       94
       98
        
       ) -> validation::Result<()> {

     

       95
       99
        
           let path = absolute_package_dir.join(subpath);

     

       96
       96
       -
           let parent_dir = path.parent().context(format!(

     

       97
       97
       -
               "Could not get parent of path {}",

     

       98
       98
       -
               subpath.display()

     

       99
       99
       -
           ))?;

     

       100
       100
       +
           let parent_dir = path

     

       101
       101
       +
               .parent()

     

       102
       102
       +
               .with_context(|| format!("Could not get parent of path {}", subpath.display()))?;

     

       100
       103
        
       

     

       101
       101
       -
           let contents =

     

       102
       102
       -
               read_to_string(&path).context(format!("Could not read file {}", subpath.display()))?;

     

       104
       104
       +
           let contents = read_to_string(&path)

     

       105
       105
       +
               .with_context(|| format!("Could not read file {}", subpath.display()))?;

     

       103
       106
        
       

     

       104
       107
        
           let root = Root::parse(&contents);

     

       105
       108
        
           if let Some(error) = root.errors().first() {

+2 -2

pkgs/test/nixpkgs-check-by-name/src/utils.rs

···

       10
       10
        
       pub fn read_dir_sorted(base_dir: &Path) -> anyhow::Result<Vec<fs::DirEntry>> {

     

       11
       11
        
           let listing = base_dir

     

       12
       12
        
               .read_dir()

     

       13
       13
       -
               .context(format!("Could not list directory {}", base_dir.display()))?;

     

       13
       13
       +
               .with_context(|| format!("Could not list directory {}", base_dir.display()))?;

     

       14
       14
        
           let mut shard_entries = listing

     

       15
       15
        
               .collect::<io::Result<Vec<_>>>()

     

       16
       16
       -
               .context(format!("Could not list directory {}", base_dir.display()))?;

     

       16
       16
       +
               .with_context(|| format!("Could not list directory {}", base_dir.display()))?;

     

       17
       17
        
           shard_entries.sort_by_key(|entry| entry.file_name());

     

       18
       18
        
           Ok(shard_entries)

     

       19
       19
        
       }

+1

pkgs/test/nixpkgs-check-by-name/tests/empty-base/default.nix

···

       1
       1
       +
       import ../mock-nixpkgs.nix { root = ./.; }

pkgs/test/nixpkgs-check-by-name/tests/empty-base/pkgs/by-name/README.md

This is a binary file and will not be displayed.

+2

pkgs/test/nixpkgs-check-by-name/tests/mock-nixpkgs.nix

···

       19
       19
        
         overlays ? [],

     

       20
       20
        
         # Passed by the checker to make sure a real Nixpkgs isn't influenced by impurities

     

       21
       21
        
         config ? {},

     

       22
       22
       +
         # Passed by the checker to make sure a real Nixpkgs isn't influenced by impurities

     

       23
       23
       +
         system ? null,

     

       22
       24
        
       }:

     

       23
       25
        
       let

     

       24
       26

+2 -2

pkgs/tools/networking/ddns-go/default.nix

···

       5
       5
        
       

     

       6
       6
        
       buildGoModule rec {

     

       7
       7
        
         pname = "ddns-go";

     

       8
       8
       -
         version = "5.7.0";

     

       8
       8
       +
         version = "5.7.1";

     

       9
       9
        
       

     

       10
       10
        
         src = fetchFromGitHub {

     

       11
       11
        
           owner = "jeessy2";

     

       12
       12
        
           repo = pname;

     

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

     

       14
       14
       -
           hash = "sha256-/GZxPM0f1W72OtpEknw0TLQ1eFDF5C98umX0Q8MX46s=";

     

       14
       14
       +
           hash = "sha256-PKshYKywqL706pVgruWQ9M0QbK2btKu28+wmnlFdDgE=";

     

       15
       15
        
         };

     

       16
       16
        
       

     

       17
       17
        
         vendorHash = "sha256-/kKFMo4PRWwXUuurNHMG36TV3EpcEikgf03/y/aKpXo=";

+3 -3

pkgs/tools/security/cryptomator/default.nix

···

       14
       14
        
       assert stdenv.isLinux; # better than `called with unexpected argument 'enableJavaFX'`

     

       15
       15
        
       mavenJdk.buildMavenPackage rec {

     

       16
       16
        
         pname = "cryptomator";

     

       17
       17
       -
         version = "1.11.0";

     

       17
       17
       +
         version = "1.11.1";

     

       18
       18
        
       

     

       19
       19
        
         src = fetchFromGitHub {

     

       20
       20
        
           owner = "cryptomator";

     

       21
       21
        
           repo = "cryptomator";

     

       22
       22
        
           rev = version;

     

       23
       23
       -
           hash = "sha256-NMNlDEUpwKUywzhXhxlNX7NiE+6wOov2Yt8nTfbKTNI=";

     

       23
       23
       +
           hash = "sha256-Y+oG2NF4Vsklp1W22Xv+XrkY6vwn23FkzAXG/5828Og=";

     

       24
       24
        
         };

     

       25
       25
        
       

     

       26
       26
        
         mvnParameters = "-Dmaven.test.skip=true -Plinux";

     

       27
       27
       -
         mvnHash = "sha256-cmwU9k7TRRJ07bT1EmY3pIBkvvqmFyE7WJeVL7VFDyc=";

     

       27
       27
       +
         mvnHash = "sha256-cXmnJHgKW6SGnhHFuFJP/DKNmFacfHbC3nQ2uVdIvUE=";

     

       28
       28
        
       

     

       29
       29
        
         preBuild = ''

     

       30
       30
        
           VERSION=${version}

+2

pkgs/top-level/all-packages.nix

···

       41457
       41457
        
       

     

       41458
       41458
        
         xpad = callPackage ../applications/misc/xpad { };

     

       41459
       41459
        
       

     

       41460
       41460
       +
         xpipe = callPackage ../applications/networking/xpipe { };

     

       41461
       41461
       +
       

     

       41460
       41462
        
         xsane = callPackage ../applications/graphics/sane/xsane.nix { };

     

       41461
       41463
        
       

     

       41462
       41464
        
         xsser = python3Packages.callPackage ../tools/security/xsser { };

+1

pkgs/top-level/python-aliases.nix

···

       342
       342
        
         pymyq = python-myq; # added 2023-10-20

     

       343
       343
        
         python-myq = throw "python-myq has been removed, as the service provider has decided to block its API requests"; # added 2023-12-07

     

       344
       344
        
         pyqt4 = throw "pyqt4 has been removed, because it depended on the long EOL qt4"; # added 2022-06-09

     

       345
       345
       +
         pyqt5_with_qtwebkit = pyqt5-webkit; # added 2024-01-07

     

       345
       346
        
         pyramid_beaker = pyramid-beaker; # added 2023-08-23

     

       346
       347
        
         pyramid_chameleon = pyramid-chameleon; # added 2023-08-23

     

       347
       348
        
         pyramid_exclog = pyramid-exclog; # added 2023-08-24

+6 -2

pkgs/top-level/python-packages.nix

···

       1487
       1487
        
       

     

       1488
       1488
        
         bip32 = callPackage ../development/python-modules/bip32 { };

     

       1489
       1489
        
       

     

       1490
       1490
       +
         birch = callPackage ../development/python-modules/birch { };

     

       1491
       1491
       +
       

     

       1490
       1492
        
         bitarray = callPackage ../development/python-modules/bitarray { };

     

       1491
       1493
        
       

     

       1492
       1494
        
         bitbox02 = callPackage ../development/python-modules/bitbox02 { };

     
···

       11008
       11010
        
         };

     

       11009
       11011
        
       

     

       11010
       11012
        
         /*

     

       11011
       11011
       -
           `pyqt5_with_qtwebkit` should not be used by python libraries in

     

       11013
       11013
       +
           `pyqt5-webkit` should not be used by python libraries in

     

       11012
       11014
        
           pkgs/development/python-modules/*. Putting this attribute in

     

       11013
       11015
        
           `propagatedBuildInputs` may cause collisions.

     

       11014
       11016
        
         */

     

       11015
       11015
       -
         pyqt5_with_qtwebkit = self.pyqt5.override {

     

       11017
       11017
       +
         pyqt5-webkit = self.pyqt5.override {

     

       11016
       11018
        
           withWebKit = true;

     

       11017
       11019
        
         };

     

       11018
       11020
        
       

     
···

       13813
       13815
        
         stravalib = callPackage ../development/python-modules/stravalib { };

     

       13814
       13816
        
       

     

       13815
       13817
        
         strawberry-graphql = callPackage ../development/python-modules/strawberry-graphql { };

     

       13818
       13818
       +
       

     

       13819
       13819
       +
         strct = callPackage ../development/python-modules/strct { };

     

       13816
       13820
        
       

     

       13817
       13821
        
         streamdeck = callPackage ../development/python-modules/streamdeck { };

     

       13818
       13822