commit fbb3e5e3f0f42f4684b83e015599ed96aaa6f76c · pyrox.dev/nixpkgs

+4

doc/release-notes/rl-2511.section.md

···

       72
       72
        
         The binary name remains `webfontkitgenerator`.

     

       73
       73
        
         The `webfontkitgenerator` package is an alias to `webfont-bundler`.

     

       74
       74
        
       

     

       75
       75
       +
       - `python3Packages.triton` no longer takes an `enableRocm` argument and supports ROCm in all build configurations via runtime binding. In most cases no action will be needed. If triton is unable to find the HIP SDK add `rocmPackages.clr` as a build input or set the environment variable `HIP_PATH="${rocmPackages.clr}"`.

     

       76
       76
       +
       

     

       75
       77
        
       - `inspircd` has been updated to the v4 release series. Please refer to the upstream documentation for [general information](https://docs.inspircd.org/4/overview/#v4-overview) and a list of [breaking changes](https://docs.inspircd.org/4/breaking-changes/).

     

       76
       78
        
       

     

       77
       79
        
       - `lima` package now only includes the guest agent for the host's architecture by default. If your guest VM's architecture differs from your Lima host's, you'll need to enable the `lima-additional-guestagents` package by setting `withAdditionalGuestAgents = true` when overriding lima with this input.

     
···

       94
       96
        
         make the required changes to your database, if needed, then upgrade by setting `services.netbox.package = pkgs.netbox_4_3;` in your configuration.

     

       95
       97
        
       

     

       96
       98
        
       - `privatebin` has been updated to `2.0.0`. This release changes configuration defaults including switching the template and removing legacy features. See the [v2.0.0 changelog entry](https://github.com/PrivateBin/PrivateBin/releases/tag/2.0.0) for details on how to upgrade.

     

       99
       99
       +
       

     

       100
       100
       +
       - `rocmPackages.triton` has been removed in favor of `python3Packages.triton`.

     

       97
       101
        
       

     

       98
       102
        
       - `go-mockery` has been updated to v3. For migration instructions see the [upstream documentation](https://vektra.github.io/mockery/latest/v3/). If v2 is still required `go-mockery_v2` has been added but will be removed on or before 2029-12-31 in-line with it's [upstream support lifecycle](https://vektra.github.io/mockery/

     

       99
       103

+1 -1

lib/lists.nix

···

       829
       829
        
           toList [ 1 2 ]

     

       830
       830
        
           => [ 1 2 ]

     

       831
       831
        
           toList "hi"

     

       832
       832
       -
           => [ "hi "]

     

       832
       832
       +
           => [ "hi" ]

     

       833
       833
        
           ```

     

       834
       834
        
       

     

       835
       835
        
           :::

+5 -1

nixos/README-modular-services.md

···

       51
       51
        
       Provide it as the first attribute in the module:

     

       52
       52
        
       

     

       53
       53
        
       ```nix

     

       54
       54
       +
       # Non-module dependencies (`importApply`)

     

       55
       55
       +
       { writeScript, runtimeShell }:

     

       56
       56
       +
       

     

       57
       57
       +
       # Service module

     

       54
       58
        
       { lib, config, ... }:

     

       55
       59
        
       {

     

       56
       60
        
         _class = "service";

     
···

       87
       91
        
         passthru = {

     

       88
       92
        
           services = {

     

       89
       93
        
             default = {

     

       90
       90
       -
               imports = [ ./service.nix ];

     

       94
       94
       +
               imports = [ (lib.modules.importApply ./service.nix { inherit pkgs; }) ];

     

       91
       95
        
               example.package = finalAttrs.finalPackage;

     

       92
       96
        
               # ...

     

       93
       97
        
             };

+11 -1

nixos/doc/manual/default.nix

···

       25
       25
        
           escapeShellArg

     

       26
       26
        
           concatMapStringsSep

     

       27
       27
        
           sourceFilesBySuffices

     

       28
       28
       +
           modules

     

       28
       29
        
           ;

     

       29
       30
        
       

     

       30
       31
        
         common = import ./common.nix;

     
···

       129
       130
        
         '';

     

       130
       131
        
       

     

       131
       132
        
         portableServiceOptions = buildPackages.nixosOptionsDoc {

     

       132
       132
       -
           inherit (evalModules { modules = [ ../../modules/system/service/portable/service.nix ]; }) options;

     

       133
       133
       +
           inherit

     

       134
       134
       +
             (evalModules {

     

       135
       135
       +
               modules = [

     

       136
       136
       +
                 (modules.importApply ../../modules/system/service/portable/service.nix {

     

       137
       137
       +
                   pkgs = throw "nixos docs / portableServiceOptions: Do not reference pkgs in docs";

     

       138
       138
       +
                 })

     

       139
       139
       +
               ];

     

       140
       140
       +
             })

     

       141
       141
       +
             options

     

       142
       142
       +
             ;

     

       133
       143
        
           inherit revision warningsAreErrors;

     

       134
       144
        
           transformOptions =

     

       135
       145
        
             opt:

+3 -1

nixos/doc/manual/development/modular-services.md

···

       85
       85
        
       

     

       86
       86
        
       ## Writing and Reviewing a Modular Service {#modular-service-review}

     

       87
       87
        
       

     

       88
       88
       -
       Refer to the contributor documentation in [`nixos/README-modular-services.md`](https://github.com/NixOS/nixpkgs/blob/master/nixos/README-modular-services.md).

     

       88
       88
       +
       A typical service module consists of the following:

     

       89
       89
       +
       

     

       90
       90
       +
       For more details, refer to the contributor documentation in [`nixos/README-modular-services.md`](https://github.com/NixOS/nixpkgs/blob/master/nixos/README-modular-services.md).

     

       89
       91
        
       

     

       90
       92
        
       ## Portable Service Options {#modular-service-options-portable}

     

       91
       93

+90

nixos/modules/system/service/README.md

···

       53
       53
        
       

     

       54
       54
        
       - **Simple attribute structure**: Unlike `environment.etc`, `configData` uses a simpler structure with just `enable`, `name`, `text`, `source`, and `path` attributes. Complex ownership options were omitted for simplicity and portability.

     

       55
       55
        
         Per-service user creation is still TBD.

     

       56
       56
       +
       

     

       57
       57
       +
       ## No `pkgs` module argument

     

       58
       58
       +
       

     

       59
       59
       +
       The modular service infrastructure avoids exposing `pkgs` as a module argument to service modules. Instead, derivations and builder functions are provided through lexical closure, making dependency relationships explicit and avoiding uncertainty about where dependencies come from.

     

       60
       60
       +
       

     

       61
       61
       +
       ### Benefits

     

       62
       62
       +
       

     

       63
       63
       +
       - **Explicit dependencies**: Services declare what they need rather than implicitly depending on `pkgs`

     

       64
       64
       +
       - **No interference**: Service modules can be reused in different contexts without assuming a specific `pkgs` instance. An unexpected `pkgs` version is not a failure mode anymore.

     

       65
       65
       +
       - **Clarity**: With fewer ways to do things, there's no ambiguity about where dependencies come from (from the module, not the OS or service manager)

     

       66
       66
       +
       

     

       67
       67
       +
       ### Implementation

     

       68
       68
       +
       

     

       69
       69
       +
       - **Portable layer**: Service modules in `portable/` do not receive `pkgs` as a module argument. Any required derivations must be provided by the caller.

     

       70
       70
       +
       

     

       71
       71
       +
       - **Systemd integration**: The `systemd/system.nix` module imports `config-data.nix` as a function, providing `pkgs` in lexical closure:

     

       72
       72
       +
         ```nix

     

       73
       73
       +
         (import ../portable/config-data.nix { inherit pkgs; })

     

       74
       74
       +
         ```

     

       75
       75
       +
       

     

       76
       76
       +
       - **Service modules**:

     

       77
       77
       +
         1. Should explicitly declare their package dependencies as options rather than using `pkgs` defaults:

     

       78
       78
       +
           ```nix

     

       79
       79
       +
           {

     

       80
       80
       +
             # Bad: uses pkgs module argument

     

       81
       81
       +
             foo.package = mkOption {

     

       82
       82
       +
               default = pkgs.python3;

     

       83
       83
       +
               # ...

     

       84
       84
       +
             };

     

       85
       85
       +
           }

     

       86
       86
       +
           ```

     

       87
       87
       +
       

     

       88
       88
       +
           ```nix

     

       89
       89
       +
           {

     

       90
       90
       +
             # Good: caller provides the package

     

       91
       91
       +
             foo.package = mkOption {

     

       92
       92
       +
               type = types.package;

     

       93
       93
       +
               description = "Python package to use";

     

       94
       94
       +
               defaultText = lib.literalMD "The package that provided this module.";

     

       95
       95
       +
             };

     

       96
       96
       +
           }

     

       97
       97
       +
           ```

     

       98
       98
       +
       

     

       99
       99
       +
         2. `passthru.services` can still provide a complete module using the package's lexical scope, making the module truly self-contained:

     

       100
       100
       +
       

     

       101
       101
       +
           **Package (`package.nix`):**

     

       102
       102
       +
           ```nix

     

       103
       103
       +
           {

     

       104
       104
       +
             lib,

     

       105
       105
       +
             writeScript,

     

       106
       106
       +
             runtimeShell,

     

       107
       107
       +
           # ... other dependencies

     

       108
       108
       +
           }:

     

       109
       109
       +
           stdenv.mkDerivation (finalAttrs: {

     

       110
       110
       +
             # ... package definition

     

       111
       111
       +
       

     

       112
       112
       +
             passthru.services.default = {

     

       113
       113
       +
               imports = [

     

       114
       114
       +
                 (lib.modules.importApply ./service.nix {

     

       115
       115
       +
                   inherit writeScript runtimeShell;

     

       116
       116
       +
                 })

     

       117
       117
       +
               ];

     

       118
       118
       +
               someService.package = finalAttrs.finalPackage;

     

       119
       119
       +
             };

     

       120
       120
       +
           })

     

       121
       121
       +
           ```

     

       122
       122
       +
       

     

       123
       123
       +
           **Service module (`service.nix`):**

     

       124
       124
       +
           ```nix

     

       125
       125
       +
           # Non-module dependencies (importApply)

     

       126
       126
       +
           { writeScript, runtimeShell }:

     

       127
       127
       +
       

     

       128
       128
       +
           # Service module

     

       129
       129
       +
           {

     

       130
       130
       +
             lib,

     

       131
       131
       +
             config,

     

       132
       132
       +
             options,

     

       133
       133
       +
             ...

     

       134
       134
       +
           }:

     

       135
       135
       +
           {

     

       136
       136
       +
             # Service definition using writeScript, runtimeShell from lexical scope

     

       137
       137
       +
             process.argv = [

     

       138
       138
       +
               (writeScript "wrapper" ''

     

       139
       139
       +
                 #!${runtimeShell}

     

       140
       140
       +
                 # ... wrapper logic

     

       141
       141
       +
               '')

     

       142
       142
       +
               # ... other args

     

       143
       143
       +
             ];

     

       144
       144
       +
           }

     

       145
       145
       +
           ```

+4 -1

nixos/modules/system/service/portable/config-data.nix

···

       1
       1
        
       # Tests in: ../../../../tests/modular-service-etc/test.nix

     

       2
       2
       +
       

     

       3
       3
       +
       # Non-modular context provided by the modular services integration.

     

       4
       4
       +
       { pkgs }:

     

       5
       5
       +
       

     

       2
       6
        
       # Configuration data support for portable services

     

       3
       7
        
       # This module provides configData for services, enabling configuration reloading

     

       4
       8
        
       # without terminating and restarting the service process.

     

       5
       9
        
       {

     

       6
       10
        
         lib,

     

       7
       7
       -
         pkgs,

     

       8
       11
        
         ...

     

       9
       12
        
       }:

     

       10
       13
        
       let

+45 -1

nixos/modules/system/service/portable/lib.nix

···

       1
       1
        
       { lib, ... }:

     

       2
       2
        
       let

     

       3
       3
       -
         inherit (lib) concatLists mapAttrsToList showOption;

     

       3
       3
       +
         inherit (lib)

     

       4
       4
       +
           concatLists

     

       5
       5
       +
           mapAttrsToList

     

       6
       6
       +
           showOption

     

       7
       7
       +
           types

     

       8
       8
       +
           ;

     

       4
       9
        
       in

     

       5
       10
        
       rec {

     

       6
       11
        
         flattenMapServicesConfigToList =

     
···

       30
       35
        
             assertion = ass.assertion;

     

       31
       36
        
           }) config.assertions

     

       32
       37
        
         );

     

       38
       38
       +
       

     

       39
       39
       +
         /**

     

       40
       40
       +
           This is the entrypoint for the portable part of modular services.

     

       41
       41
       +
       

     

       42
       42
       +
           It provides the various options that are consumed by service manager implementations.

     

       43
       43
       +
       

     

       44
       44
       +
           # Inputs

     

       45
       45
       +
       

     

       46
       46
       +
           `serviceManagerPkgs`: A Nixpkgs instance which will be used for built-in logic such as converting `configData.<path>.text` to a store path.

     

       47
       47
       +
       

     

       48
       48
       +
           `extraRootModules`: Modules to be loaded into the "root" service submodule, but not into its sub-`services`. That's the modules' own responsibility.

     

       49
       49
       +
       

     

       50
       50
       +
           `extraRootSpecialArgs`: Fixed module arguments that are provided in a similar manner to `extraRootModules`.

     

       51
       51
       +
       

     

       52
       52
       +
           # Output

     

       53
       53
       +
       

     

       54
       54
       +
           An attribute set.

     

       55
       55
       +
       

     

       56
       56
       +
           `serviceSubmodule`: a Module System option type which is a `submodule` with the portable modules and this function's inputs loaded into it.

     

       57
       57
       +
         */

     

       58
       58
       +
         configure =

     

       59
       59
       +
           {

     

       60
       60
       +
             serviceManagerPkgs,

     

       61
       61
       +
             extraRootModules ? [ ],

     

       62
       62
       +
             extraRootSpecialArgs ? { },

     

       63
       63
       +
           }:

     

       64
       64
       +
           let

     

       65
       65
       +
             modules = [

     

       66
       66
       +
               (lib.modules.importApply ./service.nix { pkgs = serviceManagerPkgs; })

     

       67
       67
       +
             ];

     

       68
       68
       +
             serviceSubmodule = types.submoduleWith {

     

       69
       69
       +
               class = "service";

     

       70
       70
       +
               modules = modules ++ extraRootModules;

     

       71
       71
       +
               specialArgs = extraRootSpecialArgs;

     

       72
       72
       +
             };

     

       73
       73
       +
           in

     

       74
       74
       +
           {

     

       75
       75
       +
             inherit serviceSubmodule;

     

       76
       76
       +
           };

     

       33
       77
        
       }

+8 -2

nixos/modules/system/service/portable/service.nix

···

       1
       1
       +
       # Non-module arguments

     

       2
       2
       +
       # These are separate from the module arguments to avoid implicit dependencies.

     

       3
       3
       +
       # This makes service modules self-contains, allowing mixing of Nixpkgs versions.

     

       4
       4
       +
       { pkgs }:

     

       5
       5
       +
       

     

       6
       6
       +
       # The module

     

       1
       7
        
       {

     

       2
       8
        
         lib,

     

       3
       9
        
         ...

     
···

       12
       18
        
         imports = [

     

       13
       19
        
           ../../../../../modules/generic/meta-maintainers.nix

     

       14
       20
        
           ../../../misc/assertions.nix

     

       15
       15
       -
           ./config-data.nix

     

       21
       21
       +
           (lib.modules.importApply ./config-data.nix { inherit pkgs; })

     

       16
       22
        
         ];

     

       17
       23
        
         options = {

     

       18
       24
        
           services = mkOption {

     

       19
       25
        
             type = types.attrsOf (

     

       20
       26
        
               types.submoduleWith {

     

       21
       27
        
                 modules = [

     

       22
       22
       -
                   ./service.nix

     

       28
       28
       +
                   (lib.modules.importApply ./service.nix { inherit pkgs; })

     

       23
       29
        
                 ];

     

       24
       30
        
               }

     

       25
       31
        
             );

+17 -9

nixos/modules/system/service/portable/test.nix

···

       7
       7
        
       

     

       8
       8
        
         portable-lib = import ./lib.nix { inherit lib; };

     

       9
       9
        
       

     

       10
       10
       +
         configured = portable-lib.configure {

     

       11
       11
       +
           serviceManagerPkgs = throw "do not use pkgs in this test";

     

       12
       12
       +
           extraRootModules = [ ];

     

       13
       13
       +
           extraRootSpecialArgs = { };

     

       14
       14
       +
         };

     

       15
       15
       +
       

     

       10
       16
        
         dummyPkg =

     

       11
       17
        
           name:

     

       12
       18
        
           derivation {

     
···

       79
       85
        
           modules = [

     

       80
       86
        
             {

     

       81
       87
        
               options.services = mkOption {

     

       82
       82
       -
                 type = types.attrsOf (

     

       83
       83
       -
                   types.submoduleWith {

     

       84
       84
       -
                     class = "service";

     

       85
       85
       -
                     modules = [

     

       86
       86
       -
                       ./service.nix

     

       87
       87
       -
                     ];

     

       88
       88
       -
                   }

     

       89
       89
       -
                 );

     

       88
       88
       +
                 type = types.attrsOf configured.serviceSubmodule;

     

       90
       89
        
               };

     

       91
       90
        
             }

     

       92
       91
        
             exampleConfig

     

       93
       92
        
           ];

     

       94
       93
        
         };

     

       95
       94
        
       

     

       95
       95
       +
         filterEval =

     

       96
       96
       +
           config:

     

       97
       97
       +
           lib.optionalAttrs (config ? process) {

     

       98
       98
       +
             inherit (config) assertions warnings process;

     

       99
       99
       +
           }

     

       100
       100
       +
           // {

     

       101
       101
       +
             services = lib.mapAttrs (k: filterEval) config.services;

     

       102
       102
       +
           };

     

       103
       103
       +
       

     

       96
       104
        
         test =

     

       97
       105
        
           assert

     

       98
       98
       -
             exampleEval.config == {

     

       106
       106
       +
             filterEval exampleEval.config == {

     

       99
       107
        
               services = {

     

       100
       108
        
                 service1 = {

     

       101
       109
        
                   process = {

+3 -1

nixos/modules/system/service/systemd/service.nix

···

       52
       52
        
       

     

       53
       53
        
       in

     

       54
       54
        
       {

     

       55
       55
       +
         _class = "service";

     

       55
       56
        
         imports = [

     

       56
       56
       -
           ../portable/service.nix

     

       57
       57
        
           (lib.mkAliasOptionModule [ "systemd" "service" ] [ "systemd" "services" "" ])

     

       58
       58
        
           (lib.mkAliasOptionModule [ "systemd" "socket" ] [ "systemd" "sockets" "" ])

     

       59
       59
        
         ];

     
···

       101
       101
        
                 };

     

       102
       102
        
               }

     

       103
       103
        
             );

     

       104
       104
       +
             # Rendered by the portable docs instead.

     

       105
       105
       +
             visible = false;

     

       104
       106
        
           };

     

       105
       107
        
         };

     

       106
       108
        
         config = {

+14 -30

nixos/modules/system/service/systemd/system.nix

···

       59
       59
        
           // concatMapAttrs (

     

       60
       60
        
             subServiceName: subService: makeUnits unitType (dash prefix subServiceName) subService

     

       61
       61
        
           ) service.services;

     

       62
       62
       +
       

     

       63
       63
       +
         modularServiceConfiguration = portable-lib.configure {

     

       64
       64
       +
           serviceManagerPkgs = pkgs;

     

       65
       65
       +
           extraRootModules = [

     

       66
       66
       +
             ./service.nix

     

       67
       67
       +
             ./config-data-path.nix

     

       68
       68
       +
           ];

     

       69
       69
       +
           extraRootSpecialArgs = {

     

       70
       70
       +
             systemdPackage = config.systemd.package;

     

       71
       71
       +
           };

     

       72
       72
       +
         };

     

       62
       73
        
       in

     

       63
       74
        
       {

     

       75
       75
       +
         _class = "nixos";

     

       76
       76
       +
       

     

       64
       77
        
         # First half of the magic: mix systemd logic into the otherwise abstract services

     

       65
       78
        
         options = {

     

       66
       79
        
           system.services = mkOption {

     

       67
       80
        
             description = ''

     

       68
       81
        
               A collection of NixOS [modular services](https://nixos.org/manual/nixos/unstable/#modular-services) that are configured as systemd services.

     

       69
       82
        
             '';

     

       70
       70
       -
             type = types.attrsOf (

     

       71
       71
       -
               types.submoduleWith {

     

       72
       72
       -
                 class = "service";

     

       73
       73
       -
                 modules = [

     

       74
       74
       -
                   ./service.nix

     

       75
       75
       -
                   ./config-data-path.nix

     

       76
       76
       -
       

     

       77
       77
       -
                   # TODO: Consider removing pkgs. Service modules can provide their own

     

       78
       78
       -
                   #       dependencies.

     

       79
       79
       -
                   {

     

       80
       80
       -
                     # Extend portable services option

     

       81
       81
       -
                     options.services = lib.mkOption {

     

       82
       82
       -
                       type = types.attrsOf (

     

       83
       83
       -
                         types.submoduleWith {

     

       84
       84
       -
                           specialArgs.pkgs = pkgs;

     

       85
       85
       -
                           modules = [ ];

     

       86
       86
       -
                         }

     

       87
       87
       -
                       );

     

       88
       88
       -
                     };

     

       89
       89
       -
                   }

     

       90
       90
       -
                 ];

     

       91
       91
       -
                 specialArgs = {

     

       92
       92
       -
                   # perhaps: features."systemd" = { };

     

       93
       93
       -
                   # TODO: Consider removing pkgs. Service modules can provide their own

     

       94
       94
       -
                   #       dependencies.

     

       95
       95
       -
                   inherit pkgs;

     

       96
       96
       -
                   systemdPackage = config.systemd.package;

     

       97
       97
       -
                 };

     

       98
       98
       -
               }

     

       99
       99
       -
             );

     

       83
       83
       +
             type = types.attrsOf modularServiceConfiguration.serviceSubmodule;

     

       100
       84
        
             default = { };

     

       101
       85
        
             visible = "shallow";

     

       102
       86
        
           };

+3 -17

nixos/tests/modular-service-etc/python-http-server.nix

···

       3
       3
        
       {

     

       4
       4
        
         config,

     

       5
       5
        
         lib,

     

       6
       6
       -
         pkgs,

     

       7
       6
        
         ...

     

       8
       7
        
       }:

     

       9
       8
        
       let

     
···

       16
       15
        
           python-http-server = {

     

       17
       16
        
             package = mkOption {

     

       18
       17
        
               type = types.package;

     

       19
       19
       -
               default = pkgs.python3;

     

       20
       18
        
               description = "Python package to use for the web server";

     

       21
       19
        
             };

     

       22
       20
        
       

     
···

       46
       44
        
           ];

     

       47
       45
        
       

     

       48
       46
        
           configData = {

     

       49
       49
       -
             # This should probably just be {} if we were to put this module in production.

     

       50
       50
       -
             "webroot" = lib.mkDefault {

     

       51
       51
       -
               source = pkgs.runCommand "default-webroot" { } ''

     

       52
       52
       -
                 mkdir -p $out

     

       53
       53
       -
                 cat > $out/index.html << 'EOF'

     

       54
       54
       -
                 <!DOCTYPE html>

     

       55
       55
       -
                 <html>

     

       56
       56
       -
                 <head><title>Python Web Server</title></head>

     

       57
       57
       -
                 <body>

     

       58
       58
       -
                   <h1>Welcome to the Python Web Server</h1>

     

       59
       59
       -
                   <p>Serving from port ${toString config.python-http-server.port}</p>

     

       60
       60
       -
                 </body>

     

       61
       61
       -
                 </html>

     

       62
       62
       -
                 EOF

     

       63
       63
       -
               '';

     

       47
       47
       +
             "webroot" = {

     

       48
       48
       +
               # Enable only if directory is set to use this path

     

       49
       49
       +
               enable = lib.mkDefault (config.python-http-server.directory == config.configData."webroot".path);

     

       64
       50
        
             };

     

       65
       51
        
           };

     

       66
       52
        
         };

+31 -4

nixos/tests/modular-service-etc/test.nix

···

       12
       12
        
         nodes = {

     

       13
       13
        
           server =

     

       14
       14
        
             { pkgs, ... }:

     

       15
       15
       +
             let

     

       16
       16
       +
               # Normally the package services.default attribute combines this, but we

     

       17
       17
       +
               # don't have that, because this is not a production service. Should it be?

     

       18
       18
       +
               python-http-server = {

     

       19
       19
       +
                 imports = [ ./python-http-server.nix ];

     

       20
       20
       +
                 python-http-server.package = pkgs.python3;

     

       21
       21
       +
               };

     

       22
       22
       +
             in

     

       15
       23
        
             {

     

       16
       24
        
               system.services.webserver = {

     

       17
       25
        
                 # The python web server is simple enough that it doesn't need a reload signal.

     

       18
       26
        
                 # Other services may need to receive a signal in order to re-read what's in `configData`.

     

       19
       19
       -
                 imports = [ ./python-http-server.nix ];

     

       27
       27
       +
                 imports = [ python-http-server ];

     

       20
       28
        
                 python-http-server = {

     

       21
       29
        
                   port = 8080;

     

       22
       30
        
                 };

     

       23
       31
        
       

     

       32
       32
       +
                 configData = {

     

       33
       33
       +
                   "webroot" = {

     

       34
       34
       +
                     source = pkgs.runCommand "webroot" { } ''

     

       35
       35
       +
                       mkdir -p $out

     

       36
       36
       +
                       cat > $out/index.html << 'EOF'

     

       37
       37
       +
                       <!DOCTYPE html>

     

       38
       38
       +
                       <html>

     

       39
       39
       +
                       <head><title>Python Web Server</title></head>

     

       40
       40
       +
                       <body>

     

       41
       41
       +
                         <h1>Welcome to the Python Web Server</h1>

     

       42
       42
       +
                         <p>Serving from port 8080</p>

     

       43
       43
       +
                       </body>

     

       44
       44
       +
                       </html>

     

       45
       45
       +
                       EOF

     

       46
       46
       +
                     '';

     

       47
       47
       +
                   };

     

       48
       48
       +
                 };

     

       49
       49
       +
       

     

       24
       50
        
                 # Add a sub-service

     

       25
       51
        
                 services.api = {

     

       26
       26
       -
                   imports = [ ./python-http-server.nix ];

     

       52
       52
       +
                   imports = [ python-http-server ];

     

       27
       53
        
                   python-http-server = {

     

       28
       54
        
                     port = 8081;

     

       29
       55
        
                   };

     
···

       147
       173
        
           print(f"Before switch - webserver PID: {webserver_pid}, api PID: {api_pid}")

     

       148
       174
        
       

     

       149
       175
        
           # Switch to the specialisation with updated content

     

       150
       150
       -
           switch_output = server.succeed("/run/current-system/specialisation/updated/bin/switch-to-configuration test")

     

       151
       151
       -
           print(f"Switch output: {switch_output}")

     

       176
       176
       +
           # Capture both stdout and stderr, and show stderr in real-time for debugging

     

       177
       177
       +
           switch_output = server.succeed("/run/current-system/specialisation/updated/bin/switch-to-configuration test 2>&1 | tee /dev/stderr")

     

       178
       178
       +
           print(f"Switch output (stdout+stderr): {switch_output}")

     

       152
       179
        
       

     

       153
       180
        
           # Verify services are not mentioned in the switch output (indicating they weren't touched)

     

       154
       181
        
           assert "webserver.service" not in switch_output, f"webserver.service was mentioned in switch output: {switch_output}"

+2

nixos/tests/php/fpm-modular.nix

···

       1
       1
       +
       # Run with:

     

       2
       2
       +
       #   nix-build -A nixosTests.php.fpm-modular

     

       1
       3
        
       { lib, php, ... }:

     

       2
       4
        
       {

     

       3
       5
        
         name = "php-${php.version}-fpm-modular-nginx-test";

+13

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

···

       7496
       7496
        
           meta.hydraPlatforms = [ ];

     

       7497
       7497
        
         };

     

       7498
       7498
        
       

     

       7499
       7499
       +
         live-preview-nvim = buildVimPlugin {

     

       7500
       7500
       +
           pname = "live-preview.nvim";

     

       7501
       7501
       +
           version = "2025-08-17";

     

       7502
       7502
       +
           src = fetchFromGitHub {

     

       7503
       7503
       +
             owner = "brianhuster";

     

       7504
       7504
       +
             repo = "live-preview.nvim";

     

       7505
       7505
       +
             rev = "5890c4f7cb81a432fd5f3b960167757f1b4d4702";

     

       7506
       7506
       +
             sha256 = "0gr68xmx9ph74pqnlpbfx9kj5bh7yg3qh0jni98z2nmkzfvg4qcx";

     

       7507
       7507
       +
           };

     

       7508
       7508
       +
           meta.homepage = "https://github.com/brianhuster/live-preview.nvim/";

     

       7509
       7509
       +
           meta.hydraPlatforms = [ ];

     

       7510
       7510
       +
         };

     

       7511
       7511
       +
       

     

       7499
       7512
        
         live-rename-nvim = buildVimPlugin {

     

       7500
       7513
        
           pname = "live-rename.nvim";

     

       7501
       7514
        
           version = "2025-06-23";

+16

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

···

       1794
       1794
        
           dependencies = [ self.litee-nvim ];

     

       1795
       1795
        
         };

     

       1796
       1796
        
       

     

       1797
       1797
       +
         live-preview-nvim = super.live-preview-nvim.overrideAttrs {

     

       1798
       1798
       +
           checkInputs = with self; [

     

       1799
       1799
       +
             fzf-lua

     

       1800
       1800
       +
             mini-pick

     

       1801
       1801
       +
             snacks-nvim

     

       1802
       1802
       +
             telescope-nvim

     

       1803
       1803
       +
           ];

     

       1804
       1804
       +
       

     

       1805
       1805
       +
           nvimSkipModules = [

     

       1806
       1806
       +
             # Ignore livepreview._spec as it fails nvimRequireCheck.

     

       1807
       1807
       +
             # This file runs tests on require which unfortunately fails as it attempts to require the base plugin. See https://github.com/brianhuster/live-preview.nvim/blob/5890c4f7cb81a432fd5f3b960167757f1b4d4702/lua/livepreview/_spec.lua#L25

     

       1808
       1808
       +
             "livepreview._spec"

     

       1809
       1809
       +
           ];

     

       1810
       1810
       +
           meta.license = lib.licenses.gpl3Only;

     

       1811
       1811
       +
         };

     

       1812
       1812
       +
       

     

       1797
       1813
        
         lspcontainers-nvim = super.lspcontainers-nvim.overrideAttrs {

     

       1798
       1814
        
           dependencies = [ self.nvim-lspconfig ];

     

       1799
       1815
        
         };

+1

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

···

       575
       575
        
       https://github.com/ldelossa/litee-symboltree.nvim/,,

     

       576
       576
        
       https://github.com/ldelossa/litee.nvim/,,

     

       577
       577
        
       https://github.com/smjonas/live-command.nvim/,HEAD,

     

       578
       578
       +
       https://github.com/brianhuster/live-preview.nvim/,HEAD,

     

       578
       579
        
       https://github.com/saecki/live-rename.nvim/,HEAD,

     

       579
       580
        
       https://github.com/azratul/live-share.nvim/,HEAD,

     

       580
       581
        
       https://github.com/ggml-org/llama.vim/,HEAD,

+3 -3

pkgs/applications/emulators/libretro/cores/mupen64plus.nix

···

       12
       12
        
       }:

     

       13
       13
        
       mkLibretroCore {

     

       14
       14
        
         core = "mupen64plus-next";

     

       15
       15
       -
         version = "0-unstable-2025-07-29";

     

       15
       15
       +
         version = "0-unstable-2025-08-20";

     

       16
       16
        
       

     

       17
       17
        
         src = fetchFromGitHub {

     

       18
       18
        
           owner = "libretro";

     

       19
       19
        
           repo = "mupen64plus-libretro-nx";

     

       20
       20
       -
           rev = "2d923939db32aad01e633010fac71f860c943a6d";

     

       21
       21
       -
           hash = "sha256-HNhGVXTeCECqOdyluPq6aYWuA612H+PCJ65XoN9WJXU=";

     

       20
       20
       +
           rev = "222acbd3f98391458a047874d0372fe78e14fe94";

     

       21
       21
       +
           hash = "sha256-esssh/0nxNUDW/eMDQbWEdcSPuqLjnKLkK4mKN17HjQ=";

     

       22
       22
        
         };

     

       23
       23
        
       

     

       24
       24
        
         # Fix for GCC 14

+2 -2

pkgs/applications/gis/qgis/unwrapped.nix

···

       82
       82
        
         ];

     

       83
       83
        
       in

     

       84
       84
        
       mkDerivation rec {

     

       85
       85
       -
         version = "3.44.1";

     

       85
       85
       +
         version = "3.44.2";

     

       86
       86
        
         pname = "qgis-unwrapped";

     

       87
       87
        
       

     

       88
       88
        
         src = fetchFromGitHub {

     

       89
       89
        
           owner = "qgis";

     

       90
       90
        
           repo = "QGIS";

     

       91
       91
        
           rev = "final-${lib.replaceStrings [ "." ] [ "_" ] version}";

     

       92
       92
       -
           hash = "sha256-WUXYjMCq95S5GHcn3pR45kpP3Us1HG4sS+EmjCBYOrM=";

     

       92
       92
       +
           hash = "sha256-ERaox5jqB7E/W0W6NnipHx1qfY2+FTHYf3r2l1KRkC0=";

     

       93
       93
        
         };

     

       94
       94
        
       

     

       95
       95
        
         passthru = {

+9

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

···

       866
       866
        
           "spdx": "Apache-2.0",

     

       867
       867
        
           "vendorHash": null

     

       868
       868
        
         },

     

       869
       869
       +
         "neon": {

     

       870
       870
       +
           "hash": "sha256-D1KWC2D4OLMUSWKzQmiZaDrATCv4SEUWwk6SK/o1U5M=",

     

       871
       871
       +
           "homepage": "https://registry.terraform.io/providers/kislerdm/neon",

     

       872
       872
       +
           "owner": "kislerdm",

     

       873
       873
       +
           "repo": "terraform-provider-neon",

     

       874
       874
       +
           "rev": "v0.9.0",

     

       875
       875
       +
           "spdx": "MPL-2.0",

     

       876
       876
       +
           "vendorHash": "sha256-8WY2iEOFOwx7zDMps5cctxzv1stRseS/OUaHkMDuBYs="

     

       877
       877
       +
         },

     

       869
       878
        
         "netlify": {

     

       870
       879
        
           "hash": "sha256-7U+hHN/6GqcbI1gX7L01YqVjlUgvdfhgpXvLF2lwbkA=",

     

       871
       880
        
           "homepage": "https://registry.terraform.io/providers/AegirHealth/netlify",

+5 -1

pkgs/by-name/_8/_86Box/package.nix

···

       28
       28
        
         libvorbis,

     

       29
       29
        
         libopus,

     

       30
       30
        
         libmpg123,

     

       31
       31
       +
         libgcrypt,

     

       31
       32
        
       

     

       32
       33
        
         enableDynarec ? with stdenv.hostPlatform; isx86 || isAarch,

     

       33
       34
        
         enableNewDynarec ? enableDynarec && stdenv.hostPlatform.isAarch,

     
···

       87
       88
        
         ]

     

       88
       89
        
         ++ lib.optional stdenv.hostPlatform.isLinux alsa-lib

     

       89
       90
        
         ++ lib.optional enableWayland wayland

     

       90
       90
       -
         ++ lib.optional enableVncRenderer libvncserver;

     

       91
       91
       +
         ++ lib.optionals enableVncRenderer [

     

       92
       92
       +
           libvncserver

     

       93
       93
       +
           libgcrypt

     

       94
       94
       +
         ];

     

       91
       95
        
       

     

       92
       96
        
         cmakeFlags =

     

       93
       97
        
           lib.optional stdenv.hostPlatform.isDarwin "-DCMAKE_MACOSX_BUNDLE=OFF"

+6 -3

pkgs/by-name/bo/bootspec/package.nix

···

       2
       2
        
         lib,

     

       3
       3
        
         rustPlatform,

     

       4
       4
        
         fetchFromGitHub,

     

       5
       5
       +
         nix-update-script,

     

       5
       6
        
       }:

     

       6
       7
        
       rustPlatform.buildRustPackage rec {

     

       7
       8
        
         pname = "bootspec";

     

       8
       8
       -
         version = "1.0.1";

     

       9
       9
       +
         version = "1.1.0";

     

       9
       10
        
       

     

       10
       11
        
         src = fetchFromGitHub {

     

       11
       12
        
           owner = "DeterminateSystems";

     

       12
       13
        
           repo = "bootspec";

     

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

     

       14
       14
       -
           hash = "sha256-0MO+SqG7Gjq+fmMJkIFvaKsfTmC7z3lGfi7bbBv7iBE=";

     

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

     

       15
       16
        
         };

     

       16
       17
        
       

     

       17
       17
       -
         cargoHash = "sha256-fKbF5SyI0UlZTWsygdE8BGWuOoNSU4jx+CGdJoJFhZs=";

     

       18
       18
       +
         cargoHash = "sha256-ZJKoL1vYfAG1rpCcE1jRm7Yj2dhooJ6iQ91c6EGF83E=";

     

       19
       19
       +
       

     

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

     

       18
       21
        
       

     

       19
       22
        
         meta = with lib; {

     

       20
       23
        
           description = "Implementation of RFC-0125's datatype and synthesis tooling";

+4 -4

pkgs/by-name/cl/claude-code/package-lock.json

···

       6
       6
        
         "packages": {

     

       7
       7
        
           "": {

     

       8
       8
        
             "dependencies": {

     

       9
       9
       -
               "@anthropic-ai/claude-code": "^1.0.92"

     

       9
       9
       +
               "@anthropic-ai/claude-code": "^1.0.93"

     

       10
       10
        
             }

     

       11
       11
        
           },

     

       12
       12
        
           "node_modules/@anthropic-ai/claude-code": {

     

       13
       13
       -
             "version": "1.0.92",

     

       14
       14
       -
             "resolved": "https://registry.npmjs.org/@anthropic-ai/claude-code/-/claude-code-1.0.92.tgz",

     

       15
       15
       -
             "integrity": "sha512-/XuwJqAvXwIGf9WeZOxHI6qQsAGzxhrRc3hyQdvwW6cU5iviTmrxWasksPbJMvFt6KQoAUU6XHs78XyYmBpOXQ==",

     

       13
       13
       +
             "version": "1.0.93",

     

       14
       14
       +
             "resolved": "https://registry.npmjs.org/@anthropic-ai/claude-code/-/claude-code-1.0.93.tgz",

     

       15
       15
       +
             "integrity": "sha512-HSrbuYVu4k1dwoj/IYsXEVSoMWDPujy2D4zl9BMt4Zt0kwUwZch0nHpTyQ0C+YeHMN7hHbViz0bw6spg0a5GgQ==",

     

       16
       16
        
             "license": "SEE LICENSE IN README.md",

     

       17
       17
        
             "bin": {

     

       18
       18
        
               "claude": "cli.js"

+3 -3

pkgs/by-name/cl/claude-code/package.nix

···

       7
       7
        
       

     

       8
       8
        
       buildNpmPackage rec {

     

       9
       9
        
         pname = "claude-code";

     

       10
       10
       -
         version = "1.0.92";

     

       10
       10
       +
         version = "1.0.93";

     

       11
       11
        
       

     

       12
       12
        
         nodejs = nodejs_20; # required for sandboxed Nix builds on Darwin

     

       13
       13
        
       

     

       14
       14
        
         src = fetchzip {

     

       15
       15
        
           url = "https://registry.npmjs.org/@anthropic-ai/claude-code/-/claude-code-${version}.tgz";

     

       16
       16
       -
           hash = "sha256-xW+oI91wL+DFaOHw5M84QJktuE9HXb031pGbrNcrpPQ=";

     

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

     

       17
       17
        
         };

     

       18
       18
        
       

     

       19
       19
       -
         npmDepsHash = "sha256-rrMskQkWKz+B5dqJ8gHgBxO20OdgE3d53TJWDxeJGbo=";

     

       19
       19
       +
         npmDepsHash = "sha256-JL0GPIhpyTQonKsyMR5zN8LaPfX3KkEfQbMR1Z7gTFE=";

     

       20
       20
        
       

     

       21
       21
        
         postPatch = ''

     

       22
       22
        
           cp ${./package-lock.json} package-lock.json

+2 -2

pkgs/by-name/fo/fosrl-pangolin/package.nix

···

       28
       28
        
       

     

       29
       29
        
       buildNpmPackage (finalAttrs: {

     

       30
       30
        
         pname = "pangolin";

     

       31
       31
       -
         version = "1.9.0";

     

       31
       31
       +
         version = "1.9.1";

     

       32
       32
        
       

     

       33
       33
        
         src = fetchFromGitHub {

     

       34
       34
        
           owner = "fosrl";

     

       35
       35
        
           repo = "pangolin";

     

       36
       36
        
           tag = finalAttrs.version;

     

       37
       37
       -
           hash = "sha256-X8Jvk/1gDj4cqXP3vlsrhWEM5lR42FsQ0HaSNeNxTXg=";

     

       37
       37
       +
           hash = "sha256-r0/HtRWdlDV749yT2pMnKqQKKYm6FPpcy3eul6M8iDQ=";

     

       38
       38
        
         };

     

       39
       39
        
       

     

       40
       40
        
         npmDepsHash = "sha256-OygskQhveT9CiymOOd5gx+aR9v3nMUZj72k/om3IF/c=";

+7 -1

pkgs/by-name/gh/ghostunnel/package.nix

···

       7
       7
        
         ghostunnel,

     

       8
       8
        
         apple-sdk_12,

     

       9
       9
        
         darwinMinVersionHook,

     

       10
       10
       +
         writeScript,

     

       11
       11
       +
         runtimeShell,

     

       10
       12
        
       }:

     

       11
       13
        
       

     

       12
       14
        
       buildGoModule rec {

     
···

       41
       43
        
         };

     

       42
       44
        
       

     

       43
       45
        
         passthru.services.default = {

     

       44
       44
       -
           imports = [ ./service.nix ];

     

       46
       46
       +
           imports = [

     

       47
       47
       +
             (lib.modules.importApply ./service.nix {

     

       48
       48
       +
               inherit writeScript runtimeShell;

     

       49
       49
       +
             })

     

       50
       50
       +
           ];

     

       45
       51
        
           ghostunnel.package = ghostunnel; # FIXME: finalAttrs.finalPackage

     

       46
       52
        
         };

     

       47
       53

+7 -3

pkgs/by-name/gh/ghostunnel/service.nix

···

       1
       1
       +
       # Non-module dependencies (`importApply`)

     

       2
       2
       +
       { writeScript, runtimeShell }:

     

       3
       3
       +
       

     

       4
       4
       +
       # Service module

     

       1
       5
        
       {

     

       2
       6
        
         lib,

     

       3
       7
        
         config,

     

       4
       8
        
         options,

     

       5
       5
       -
         pkgs,

     

       6
       9
        
         ...

     

       7
       10
        
       }:

     

       8
       11
        
       let

     
···

       25
       28
        
           ghostunnel = {

     

       26
       29
        
             package = mkOption {

     

       27
       30
        
               description = "Package to use for ghostunnel";

     

       31
       31
       +
               defaultText = "The ghostunnel package that provided this module.";

     

       28
       32
        
               type = types.package;

     

       29
       33
        
             };

     

       30
       34
        
       

     
···

       191
       195
        
                   cfg.cacert

     

       192
       196
        
                 ])

     

       193
       197
        
                 (

     

       194
       194
       -
                   pkgs.writeScript "load-credentials" ''

     

       195
       195
       -
                     #!${pkgs.runtimeShell}

     

       198
       198
       +
                   writeScript "load-credentials" ''

     

       199
       199
       +
                     #!${runtimeShell}

     

       196
       200
        
                     exec $@ ${

     

       197
       201
        
                       concatStringsSep " " (

     

       198
       202
        
                         optional (cfg.keystore != null) "--keystore=$CREDENTIALS_DIRECTORY/keystore"

+72

pkgs/by-name/ka/kawa/package.nix

···

       1
       1
       +
       {

     

       2
       2
       +
         lib,

     

       3
       3
       +
         stdenv,

     

       4
       4
       +
         fetchurl,

     

       5
       5
       +
         jdk11,

     

       6
       6
       +
         ant,

     

       7
       7
       +
         makeWrapper,

     

       8
       8
       +
       }:

     

       9
       9
       +
       

     

       10
       10
       +
       stdenv.mkDerivation (finalAttrs: {

     

       11
       11
       +
         pname = "kawa";

     

       12
       12
       +
         version = "3.1.1";

     

       13
       13
       +
       

     

       14
       14
       +
         src = fetchurl {

     

       15
       15
       +
           url = "mirror://gnu/kawa/kawa-${finalAttrs.version}.tar.gz";

     

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

     

       17
       17
       +
         };

     

       18
       18
       +
       

     

       19
       19
       +
         nativeBuildInputs = [

     

       20
       20
       +
           jdk11

     

       21
       21
       +
           ant

     

       22
       22
       +
           makeWrapper

     

       23
       23
       +
         ];

     

       24
       24
       +
       

     

       25
       25
       +
         buildPhase = ''

     

       26
       26
       +
           runHook preBuild

     

       27
       27
       +
       

     

       28
       28
       +
           ant -Denable-java-frontend=yes

     

       29
       29
       +
       

     

       30
       30
       +
           runHook postBuild

     

       31
       31
       +
         '';

     

       32
       32
       +
       

     

       33
       33
       +
         installPhase = ''

     

       34
       34
       +
           runHook preInstall

     

       35
       35
       +
       

     

       36
       36
       +
           mkdir -p $out/share/java

     

       37
       37
       +
           cp lib/kawa.jar $out/share/java/kawa.jar

     

       38
       38
       +
       

     

       39
       39
       +
           # Install info files

     

       40
       40
       +
           mkdir -p $out/share/info

     

       41
       41
       +
           cp doc/*.info* $out/share/info/

     

       42
       42
       +
       

     

       43
       43
       +
           # Install man pages

     

       44
       44
       +
           mkdir -p $out/share/man/man1

     

       45
       45
       +
           cp doc/kawa.man $out/share/man/man1/kawa.1

     

       46
       46
       +
           cp doc/qexo.man $out/share/man/man1/qexo.1

     

       47
       47
       +
       

     

       48
       48
       +
           mkdir -p $out/bin

     

       49
       49
       +
           makeWrapper ${jdk11}/bin/java $out/bin/kawa \

     

       50
       50
       +
             --add-flags "-Dkawa.home=$out -jar $out/share/java/kawa.jar"

     

       51
       51
       +
       

     

       52
       52
       +
           runHook postInstall

     

       53
       53
       +
         '';

     

       54
       54
       +
       

     

       55
       55
       +
         meta = {

     

       56
       56
       +
           description = "Scheme implementation running on the Java platform";

     

       57
       57
       +
           longDescription = ''

     

       58
       58
       +
             Kawa is a general-purpose programming language that runs on the Java platform.

     

       59
       59
       +
             It aims to combine the benefits of dynamic scripting languages (less boiler-plate

     

       60
       60
       +
             code, fast and easy start-up, a REPL, no required compilation step) with the

     

       61
       61
       +
             benefits of traditional compiled languages (fast execution, static error detection,

     

       62
       62
       +
             modularity, zero-overhead Java platform integration).

     

       63
       63
       +
           '';

     

       64
       64
       +
           homepage = "https://www.gnu.org/software/kawa";

     

       65
       65
       +
           license = [

     

       66
       66
       +
             lib.licenses.mit

     

       67
       67
       +
             lib.licenses.gpl2Plus

     

       68
       68
       +
           ];

     

       69
       69
       +
           maintainers = with lib.maintainers; [ siraben ];

     

       70
       70
       +
           platforms = lib.platforms.unix;

     

       71
       71
       +
         };

     

       72
       72
       +
       })

+52

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

···

       1
       1
       +
       {

     

       2
       2
       +
         lib,

     

       3
       3
       +
         stdenv,

     

       4
       4
       +
         fetchFromGitHub,

     

       5
       5
       +
         libsodium,

     

       6
       6
       +
         liboprf,

     

       7
       7
       +
         testers,

     

       8
       8
       +
         nix-update-script,

     

       9
       9
       +
       }:

     

       10
       10
       +
       

     

       11
       11
       +
       stdenv.mkDerivation (finalAttrs: {

     

       12
       12
       +
         pname = "libopaque";

     

       13
       13
       +
         version = "1.0.1";

     

       14
       14
       +
       

     

       15
       15
       +
         src = fetchFromGitHub {

     

       16
       16
       +
           owner = "stef";

     

       17
       17
       +
           repo = "libopaque";

     

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

     

       19
       19
       +
           hash = "sha256-VVD4489yWAJTWLGrpXYe8or5QjDnAuQ9/tzlNJJu/lo=";

     

       20
       20
       +
         };

     

       21
       21
       +
       

     

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

     

       23
       23
       +
       

     

       24
       24
       +
         strictDeps = true;

     

       25
       25
       +
       

     

       26
       26
       +
         buildInputs = [

     

       27
       27
       +
           libsodium

     

       28
       28
       +
           liboprf

     

       29
       29
       +
         ];

     

       30
       30
       +
       

     

       31
       31
       +
         postInstall = ''

     

       32
       32
       +
           mkdir -p ${placeholder "out"}/lib/pkgconfig

     

       33
       33
       +
           cp ../libopaque.pc ${placeholder "out"}/lib/pkgconfig/

     

       34
       34
       +
         '';

     

       35
       35
       +
       

     

       36
       36
       +
         makeFlags = [ "PREFIX=$(out)" ];

     

       37
       37
       +
       

     

       38
       38
       +
         passthru = {

     

       39
       39
       +
           tests.pkg-config = testers.testMetaPkgConfig finalAttrs.finalPackage;

     

       40
       40
       +
           updateScript = nix-update-script { };

     

       41
       41
       +
         };

     

       42
       42
       +
       

     

       43
       43
       +
         meta = {

     

       44
       44
       +
           description = "Implementation of the OPAQUE protocol with support for threshold variants";

     

       45
       45
       +
           homepage = "https://github.com/stef/libopaque/";

     

       46
       46
       +
           changelog = "https://github.com/stef/libopaque/releases/tag/v${finalAttrs.version}";

     

       47
       47
       +
           license = lib.licenses.lgpl3Plus;

     

       48
       48
       +
           teams = [ lib.teams.ngi ];

     

       49
       49
       +
           platforms = lib.platforms.unix;

     

       50
       50
       +
           pkgConfigModules = [ "libopaque" ];

     

       51
       51
       +
         };

     

       52
       52
       +
       })

+3 -3

pkgs/by-name/mi/mise/package.nix

···

       21
       21
        
       

     

       22
       22
        
       rustPlatform.buildRustPackage rec {

     

       23
       23
        
         pname = "mise";

     

       24
       24
       -
         version = "2025.8.10";

     

       24
       24
       +
         version = "2025.8.20";

     

       25
       25
        
       

     

       26
       26
        
         src = fetchFromGitHub {

     

       27
       27
        
           owner = "jdx";

     

       28
       28
        
           repo = "mise";

     

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

     

       30
       30
       -
           hash = "sha256-ycYB/XuaTwGmXzh59cxt5KC1v0gqoTB67MMmpCsR6o8=";

     

       30
       30
       +
           hash = "sha256-zjb0ND6U/fe/1h+0LdTDYLIpsSPTvGhWOhFOb4vmiT0=";

     

       31
       31
        
         };

     

       32
       32
        
       

     

       33
       33
       -
         cargoHash = "sha256-9YHW8jO+K1YZjmfN+KxctConrvp6yYODnRoSwIFxryU=";

     

       33
       33
       +
         cargoHash = "sha256-kebXsDAtQjEtAVCD76n5/A9hB1Sj+ww9MoHcfm/ucBs=";

     

       34
       34
        
       

     

       35
       35
        
         nativeBuildInputs = [

     

       36
       36
        
           installShellFiles

+3 -3

pkgs/by-name/op/open-webui/package.nix

···

       9
       9
        
       }:

     

       10
       10
        
       let

     

       11
       11
        
         pname = "open-webui";

     

       12
       12
       -
         version = "0.6.22";

     

       12
       12
       +
         version = "0.6.25";

     

       13
       13
        
       

     

       14
       14
        
         src = fetchFromGitHub {

     

       15
       15
        
           owner = "open-webui";

     

       16
       16
        
           repo = "open-webui";

     

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

     

       18
       18
       -
           hash = "sha256-SX2uLmDZu1TW45A6F5mSXVtSqv5rbNKuVw8sWj8tEb4=";

     

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

     

       19
       19
        
         };

     

       20
       20
        
       

     

       21
       21
        
         frontend = buildNpmPackage rec {

     
···

       32
       32
        
             url = "https://github.com/pyodide/pyodide/releases/download/${pyodideVersion}/pyodide-${pyodideVersion}.tar.bz2";

     

       33
       33
        
           };

     

       34
       34
        
       

     

       35
       35
       -
           npmDepsHash = "sha256-mMnDYMy1/7gW6XVaWVct9BuxDP78XX5u46lGBWjUvOQ=";

     

       35
       35
       +
           npmDepsHash = "sha256-WL1kdXn7uAaBEwWiIJzzisMZ1uiaOVtFViWK/kW6lsY=";

     

       36
       36
        
       

     

       37
       37
        
           # See https://github.com/open-webui/open-webui/issues/15880

     

       38
       38
        
           npmFlags = [

+4

pkgs/by-name/os/osm-gps-map/package.nix

···

       7
       7
        
         gnome-common,

     

       8
       8
        
         gtk3,

     

       9
       9
        
         gobject-introspection,

     

       10
       10
       +
         autoreconfHook,

     

       11
       11
       +
         gtk-doc,

     

       10
       12
        
         pkg-config,

     

       11
       13
        
         lib,

     

       12
       14
        
         stdenv,

     
···

       50
       52
        
         ];

     

       51
       53
        
       

     

       52
       54
        
         nativeBuildInputs = [

     

       55
       55
       +
           autoreconfHook

     

       56
       56
       +
           gtk-doc

     

       53
       57
        
           pkg-config

     

       54
       58
        
           gobject-introspection

     

       55
       59
        
           gnome-common

+3 -3

pkgs/by-name/pa/pay-respects/package.nix

···

       6
       6
        
       }:

     

       7
       7
        
       rustPlatform.buildRustPackage (finalAttrs: {

     

       8
       8
        
         pname = "pay-respects";

     

       9
       9
       -
         version = "0.7.8";

     

       9
       9
       +
         version = "0.7.9";

     

       10
       10
        
       

     

       11
       11
        
         src = fetchFromGitea {

     

       12
       12
        
           domain = "codeberg.org";

     

       13
       13
        
           owner = "iff";

     

       14
       14
        
           repo = "pay-respects";

     

       15
       15
        
           tag = "v${finalAttrs.version}";

     

       16
       16
       -
           hash = "sha256-73uGxcJCWUVwr1ddNjZTRJwx8OfnAPwtp80v1xpUEhA=";

     

       16
       16
       +
           hash = "sha256-qKej29kM0Kq5RRHo+lu9cGeTjnjUvpmIqSxq5yHuCKc=";

     

       17
       17
        
         };

     

       18
       18
        
       

     

       19
       19
       -
         cargoHash = "sha256-VSv0BpIICkYyCIfGDfK7wfKQssWF13hCh6IW375CI/c=";

     

       19
       19
       +
         cargoHash = "sha256-2MEbUBTZ/zsPLhHTnQCrWQManqUQ3V3xta5NT9gu38A=";

     

       20
       20
        
       

     

       21
       21
        
         nativeInstallCheckInputs = [ versionCheckHook ];

     

       22
       22
        
         doInstallCheck = true;

+3 -3

pkgs/by-name/te/telepresence2/package.nix

···

       31
       31
        
       in

     

       32
       32
        
       buildGoModule rec {

     

       33
       33
        
         pname = "telepresence2";

     

       34
       34
       -
         version = "2.23.6";

     

       34
       34
       +
         version = "2.24.0";

     

       35
       35
        
       

     

       36
       36
        
         src = fetchFromGitHub {

     

       37
       37
        
           owner = "telepresenceio";

     

       38
       38
        
           repo = "telepresence";

     

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

     

       40
       40
       -
           hash = "sha256-bo98R5uWOg219JF5czUd3XPznyXpphQMJtsgF5xJFqE=";

     

       40
       40
       +
           hash = "sha256-aqL2AjDscN6o9WKur3ed5SU3XQJy6hAu/QUD7Fh/0pE=";

     

       41
       41
        
         };

     

       42
       42
        
       

     

       43
       43
        
         propagatedBuildInputs = [

     
···

       51
       51
        
           export CGO_ENABLED=0

     

       52
       52
        
         '';

     

       53
       53
        
       

     

       54
       54
       -
         vendorHash = "sha256-DAbPgLt0CGdbfDmMXZDyjStyeb4A1dPCNiJMH1NUAUg=";

     

       54
       54
       +
         vendorHash = "sha256-ncMquDrlkcf71voCbxadOM+EKO/7olMEAf5FOFoxrvA=";

     

       55
       55
        
       

     

       56
       56
        
         ldflags = [

     

       57
       57
        
           "-s"

+46 -37

pkgs/by-name/vi/virglrenderer/package.nix

···

       1
       1
        
       {

     

       2
       2
        
         lib,

     

       3
       3
        
         stdenv,

     

       4
       4
       -
         fetchurl,

     

       4
       4
       +
         fetchFromGitLab,

     

       5
       5
        
         meson,

     

       6
       6
        
         ninja,

     

       7
       7
        
         pkg-config,

     
···

       11
       11
        
         libX11,

     

       12
       12
        
         libdrm,

     

       13
       13
        
         libgbm,

     

       14
       14
       -
         nativeContextSupport ? stdenv.hostPlatform.isLinux,

     

       15
       15
       -
         vaapiSupport ? !stdenv.hostPlatform.isDarwin,

     

       16
       14
        
         libva,

     

       17
       17
       -
         vulkanSupport ? stdenv.hostPlatform.isLinux,

     

       18
       15
        
         vulkan-headers,

     

       19
       16
        
         vulkan-loader,

     

       20
       20
       -
         gitUpdater,

     

       17
       17
       +
         nix-update-script,

     

       18
       18
       +
         vulkanSupport ? stdenv.hostPlatform.isLinux,

     

       19
       19
       +
         nativeContextSupport ? stdenv.hostPlatform.isLinux,

     

       20
       20
       +
         vaapiSupport ? !stdenv.hostPlatform.isDarwin,

     

       21
       21
        
       }:

     

       22
       22
        
       

     

       23
       23
       -
       stdenv.mkDerivation rec {

     

       23
       23
       +
       stdenv.mkDerivation (finalAttrs: {

     

       24
       24
        
         pname = "virglrenderer";

     

       25
       25
        
         version = "1.1.1";

     

       26
       26
        
       

     

       27
       27
       -
         src = fetchurl {

     

       28
       28
       -
           url = "https://gitlab.freedesktop.org/virgl/virglrenderer/-/archive/${version}/virglrenderer-${version}.tar.bz2";

     

       29
       29
       -
           hash = "sha256-D+SJqBL76z1nGBmcJ7Dzb41RvFxU2Ak6rVOwDRB94rM=";

     

       27
       27
       +
         src = fetchFromGitLab {

     

       28
       28
       +
           domain = "gitlab.freedesktop.org";

     

       29
       29
       +
           owner = "virgl";

     

       30
       30
       +
           repo = "virglrenderer";

     

       31
       31
       +
           tag = finalAttrs.version;

     

       32
       32
       +
           hash = "sha256-ah6+AAf7B15rPMb4uO873wieT3+gf/5iGH+ZFoZKAAI=";

     

       30
       33
        
         };

     

       31
       34
        
       

     

       32
       35
        
         separateDebugInfo = true;

     

       33
       36
        
       

     

       37
       37
       +
         nativeBuildInputs = [

     

       38
       38
       +
           meson

     

       39
       39
       +
           ninja

     

       40
       40
       +
           pkg-config

     

       41
       41
       +
           (buildPackages.python3.withPackages (ps: [

     

       42
       42
       +
             ps.pyyaml

     

       43
       43
       +
           ]))

     

       44
       44
       +
         ];

     

       45
       45
       +
       

     

       34
       46
        
         buildInputs = [

     

       35
       47
        
           libepoxy

     

       36
       48
        
         ]

     

       37
       37
       -
         ++ lib.optionals vaapiSupport [ libva ]

     

       38
       38
       -
         ++ lib.optionals vulkanSupport [

     

       39
       39
       -
           vulkan-headers

     

       40
       40
       -
           vulkan-loader

     

       41
       41
       -
         ]

     

       42
       49
        
         ++ lib.optionals stdenv.hostPlatform.isLinux [

     

       43
       50
        
           libGLU

     

       44
       51
        
           libX11

     

       45
       52
        
           libdrm

     

       46
       53
        
           libgbm

     

       47
       47
       -
         ];

     

       48
       48
       -
       

     

       49
       49
       -
         nativeBuildInputs = [

     

       50
       50
       -
           meson

     

       51
       51
       -
           ninja

     

       52
       52
       -
           pkg-config

     

       53
       53
       -
           (buildPackages.python3.withPackages (ps: [

     

       54
       54
       -
             ps.pyyaml

     

       55
       55
       -
           ]))

     

       54
       54
       +
         ]

     

       55
       55
       +
         ++ lib.optionals vaapiSupport [

     

       56
       56
       +
           libva

     

       57
       57
       +
         ]

     

       58
       58
       +
         ++ lib.optionals vulkanSupport [

     

       59
       59
       +
           vulkan-headers

     

       60
       60
       +
           vulkan-loader

     

       56
       61
        
         ];

     

       57
       62
        
       

     

       58
       63
        
         mesonFlags = [

     

       59
       64
        
           (lib.mesonBool "video" vaapiSupport)

     

       60
       65
        
           (lib.mesonBool "venus" vulkanSupport)

     

       61
       61
       -
         ]

     

       62
       62
       -
         ++ lib.optionals nativeContextSupport [

     

       63
       63
       -
           (lib.mesonOption "drm-renderers" "amdgpu-experimental,msm")

     

       66
       66
       +
           (lib.mesonOption "drm-renderers" (

     

       67
       67
       +
             lib.optionalString nativeContextSupport (

     

       68
       68
       +
               lib.concatStringsSep "," [

     

       69
       69
       +
                 "amdgpu-experimental"

     

       70
       70
       +
                 "msm"

     

       71
       71
       +
               ]

     

       72
       72
       +
             )

     

       73
       73
       +
           ))

     

       64
       74
        
         ];

     

       65
       75
        
       

     

       66
       76
        
         passthru = {

     

       67
       67
       -
           updateScript = gitUpdater {

     

       68
       68
       -
             url = "https://gitlab.freedesktop.org/virgl/virglrenderer.git";

     

       69
       69
       -
             rev-prefix = "virglrenderer-";

     

       70
       70
       -
           };

     

       77
       77
       +
           updateScript = nix-update-script { };

     

       71
       78
        
         };

     

       72
       79
        
       

     

       73
       73
       -
         meta = with lib; {

     

       74
       74
       -
           description = "Virtual 3D GPU library that allows a qemu guest to use the host GPU for accelerated 3D rendering";

     

       80
       80
       +
         meta = {

     

       81
       81
       +
           description = "Virtual 3D GPU for use inside QEMU virtual machines";

     

       82
       82
       +
           homepage = "https://docs.mesa3d.org/drivers/virgl";

     

       83
       83
       +
           license = lib.licenses.mit;

     

       84
       84
       +
           maintainers = with lib.maintainers; [

     

       85
       85
       +
             normalcea

     

       86
       86
       +
           ];

     

       75
       87
        
           mainProgram = "virgl_test_server";

     

       76
       76
       -
           homepage = "https://virgil3d.github.io/";

     

       77
       77
       -
           license = licenses.mit;

     

       78
       78
       -
           platforms = platforms.unix;

     

       79
       79
       -
           maintainers = [ maintainers.xeji ];

     

       88
       88
       +
           platforms = lib.platforms.unix;

     

       80
       89
        
         };

     

       81
       81
       -
       }

     

       90
       90
       +
       })

+2 -2

pkgs/by-name/xe/xed-editor/package.nix

···

       21
       21
        
       

     

       22
       22
        
       stdenv.mkDerivation rec {

     

       23
       23
        
         pname = "xed-editor";

     

       24
       24
       -
         version = "3.8.3";

     

       24
       24
       +
         version = "3.8.4";

     

       25
       25
        
       

     

       26
       26
        
         src = fetchFromGitHub {

     

       27
       27
        
           owner = "linuxmint";

     

       28
       28
        
           repo = "xed";

     

       29
       29
        
           rev = version;

     

       30
       30
       -
           hash = "sha256-bNnxQOYDBS/pNaBwvmrt/VAya/m7t5H40lJkFevufUE=";

     

       30
       30
       +
           hash = "sha256-pI9gjAA5dn0QwZKGungQ1xpQJmnfCxmqWR0VBEQ5v84=";

     

       31
       31
        
         };

     

       32
       32
        
       

     

       33
       33
        
         patches = [

+2 -2

pkgs/by-name/xv/xviewer/package.nix

···

       28
       28
        
       

     

       29
       29
        
       stdenv.mkDerivation rec {

     

       30
       30
        
         pname = "xviewer";

     

       31
       31
       -
         version = "3.4.11";

     

       31
       31
       +
         version = "3.4.12";

     

       32
       32
        
       

     

       33
       33
        
         src = fetchFromGitHub {

     

       34
       34
        
           owner = "linuxmint";

     

       35
       35
        
           repo = "xviewer";

     

       36
       36
        
           rev = version;

     

       37
       37
       -
           hash = "sha256-fW+hhHJ4i3u0vtbvaQWliIZSLI1WCFhR5CvVZL6Vy8U=";

     

       37
       37
       +
           hash = "sha256-WvA8T6r9DtlpOZLMEOILO6/0Am3bhCLM8FnwXvALjS8=";

     

       38
       38
        
         };

     

       39
       39
        
       

     

       40
       40
        
         nativeBuildInputs = [

-2

pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml

···

       437
       437
        
           - hercules-ci-cnix-store

     

       438
       438
        
           - inline-c

     

       439
       439
        
           - inline-c-cpp

     

       440
       440
       -
         roosemberth:

     

       441
       441
       -
           - git-annex

     

       442
       440
        
         rvl:

     

       443
       441
        
           - taffybar

     

       444
       442
        
           - arbtt

+7 -1

pkgs/development/interpreters/php/generic.nix

···

       32
       32
        
             common-updater-scripts,

     

       33
       33
        
             curl,

     

       34
       34
        
             jq,

     

       35
       35
       +
             coreutils,

     

       36
       36
       +
             formats,

     

       35
       37
        
       

     

       36
       38
        
             version,

     

       37
       39
        
             phpSrc ? null,

     
···

       390
       392
        
                   inherit ztsSupport;

     

       391
       393
        
       

     

       392
       394
        
                   services.default = {

     

       393
       393
       -
                     imports = [ ./service.nix ];

     

       395
       395
       +
                     imports = [

     

       396
       396
       +
                       (lib.modules.importApply ./service.nix {

     

       397
       397
       +
                         inherit formats coreutils;

     

       398
       398
       +
                       })

     

       399
       399
       +
                     ];

     

       394
       400
        
                     php-fpm.package = lib.mkDefault finalAttrs.finalPackage;

     

       395
       401
        
                   };

     

       396
       402
        
                 };

+14 -6

pkgs/development/interpreters/php/service.nix

···

       1
       1
       +
       # Tests in: nixos/tests/php/fpm-modular.nix

     

       2
       2
       +
       

     

       3
       3
       +
       # Non-module dependencies (importApply)

     

       4
       4
       +
       { formats, coreutils }:

     

       5
       5
       +
       

     

       6
       6
       +
       # Service module

     

       1
       7
        
       {

     

       2
       8
        
         options,

     

       3
       9
        
         config,

     

       4
       4
       -
         pkgs,

     

       5
       10
        
         lib,

     

       6
       11
        
         ...

     

       7
       12
        
       }:

     

       8
       13
        
       let

     

       9
       14
        
         cfg = config.php-fpm;

     

       10
       10
       -
         format = pkgs.formats.iniWithGlobalSection { };

     

       15
       15
       +
         format = formats.iniWithGlobalSection { };

     

       11
       16
        
         configFile = format.generate "php-fpm.conf" {

     

       12
       17
        
           globalSection = lib.filterAttrs (_: v: !lib.isAttrs v) cfg.settings;

     

       13
       18
        
           sections = lib.filterAttrs (_: lib.isAttrs) cfg.settings;

     
···

       76
       81
        
         _class = "service";

     

       77
       82
        
       

     

       78
       83
        
         options.php-fpm = {

     

       79
       79
       -
           package = lib.mkPackageOption pkgs "php" {

     

       80
       80
       -
             example = ''

     

       84
       84
       +
           package = lib.mkOption {

     

       85
       85
       +
             type = lib.types.package;

     

       86
       86
       +
             description = "PHP package to use for php-fpm";

     

       87
       87
       +
             defaultText = lib.literalMD ''The PHP package that provided this module.'';

     

       88
       88
       +
             example = lib.literalExpression ''

     

       81
       89
        
               php.buildEnv {

     

       82
       90
        
                 extensions =

     

       83
       91
        
                   { all, ... }:

     
···

       163
       171
        
       

     

       164
       172
        
             serviceConfig = {

     

       165
       173
        
               Type = "notify";

     

       166
       166
       -
               ExecReload = "${pkgs.coreutils}/bin/kill -USR2 $MAINPID";

     

       174
       174
       +
               ExecReload = "${coreutils}/bin/kill -USR2 $MAINPID";

     

       167
       175
        
               RuntimeDirectory = "php-fpm";

     

       168
       176
        
               RuntimeDirectoryPreserve = true;

     

       169
       177
        
               Restart = "always";

     
···

       175
       183
        
       

     

       176
       184
        
           finit.service = {

     

       177
       185
        
             conditions = [ "service/syslogd/ready" ];

     

       178
       178
       -
             reload = "${pkgs.coreutils}/bin/kill -USR2 $MAINPID";

     

       186
       186
       +
             reload = "${coreutils}/bin/kill -USR2 $MAINPID";

     

       179
       187
        
             notify = "systemd";

     

       180
       188
        
           };

     

       181
       189
        
         };

+2 -2

pkgs/development/ocaml-modules/dune-rpc/default.nix

···

       4
       4
        
         dune_3,

     

       5
       5
        
         csexp,

     

       6
       6
        
         stdune,

     

       7
       7
       +
         ocamlc-loc,

     

       7
       8
        
         ordering,

     

       8
       8
       -
         pp,

     

       9
       9
        
         xdg,

     

       10
       10
        
         dyn,

     

       11
       11
        
       }:

     
···

       21
       21
        
         propagatedBuildInputs = [

     

       22
       22
        
           csexp

     

       23
       23
        
           stdune

     

       24
       24
       +
           ocamlc-loc

     

       24
       25
        
           ordering

     

       25
       25
       -
           pp

     

       26
       26
        
           xdg

     

       27
       27
        
           dyn

     

       28
       28
        
         ];

+17 -6

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

···

       14
       14
        
         exceptiongroup,

     

       15
       15
        
         httpx,

     

       16
       16
        
         mcp,

     

       17
       17
       +
         openapi-core,

     

       17
       18
        
         openapi-pydantic,

     

       18
       19
        
         pydantic,

     

       19
       20
        
         pyperclip,

     
···

       31
       32
        
       

     

       32
       33
        
       buildPythonPackage rec {

     

       33
       34
        
         pname = "fastmcp";

     

       34
       34
       -
         version = "2.11.1";

     

       35
       35
       +
         version = "2.11.3";

     

       35
       36
        
         pyproject = true;

     

       36
       37
        
       

     

       37
       38
        
         src = fetchFromGitHub {

     

       38
       39
        
           owner = "jlowin";

     

       39
       40
        
           repo = "fastmcp";

     

       40
       41
        
           tag = "v${version}";

     

       41
       41
       -
           hash = "sha256-Y71AJdWcRBDbq63p+lcQplqutz2UTQ3f+pTyhcolpuw=";

     

       42
       42
       +
           hash = "sha256-jIXrMyNnyPE2DUgg+sxT6LD4dTmKQglh4cFuaw179Z0=";

     

       42
       43
        
         };

     

       43
       44
        
       

     

       44
       45
        
         postPatch = ''

     
···

       57
       58
        
           exceptiongroup

     

       58
       59
        
           httpx

     

       59
       60
        
           mcp

     

       61
       61
       +
           openapi-core

     

       60
       62
        
           openapi-pydantic

     

       61
       63
        
           pyperclip

     

       62
       64
        
           python-dotenv

     
···

       87
       89
        
           "test_keep_alive_starts_new_session_if_manually_closed"

     

       88
       90
        
           "test_keep_alive_maintains_session_if_reentered"

     

       89
       91
        
           "test_close_session_and_try_to_use_client_raises_error"

     

       92
       92
       +
           "test_run_mcp_config"

     

       93
       93
       +
           "test_uv_transport"

     

       94
       94
       +
           "test_uv_transport_module"

     

       95
       95
       +
           "test_github_api_schema_performance"

     

       90
       96
        
       

     

       91
       97
        
           # RuntimeError: Client failed to connect: Timed out while waiting for response

     

       92
       98
        
           "test_timeout"

     
···

       94
       100
        
       

     

       95
       101
        
           # assert 0 == 2

     

       96
       102
        
           "test_multi_client"

     

       103
       103
       +
           "test_canonical_multi_client_with_transforms"

     

       97
       104
        
       

     

       98
       105
        
           # fastmcp.exceptions.ToolError: Unknown tool

     

       99
       106
        
           "test_multi_client_with_logging"

     

       100
       107
        
           "test_multi_client_with_elicitation"

     

       108
       108
       +
         ]

     

       109
       109
       +
         ++ lib.optionals stdenv.hostPlatform.isDarwin [

     

       110
       110
       +
           # RuntimeError: Server failed to start after 10 attempts

     

       111
       111
       +
           "test_unauthorized_access"

     

       101
       112
        
         ];

     

       102
       113
        
       

     

       103
       114
        
         disabledTestPaths = lib.optionals stdenv.hostPlatform.isDarwin [

     

       104
       115
        
           # RuntimeError: Server failed to start after 10 attempts

     

       105
       105
       -
           "tests/auth/providers/test_bearer.py"

     

       106
       106
       -
           "tests/auth/test_oauth_client.py"

     

       107
       107
       -
           "tests/client/test_openapi.py"

     

       116
       116
       +
           "tests/client/auth/test_oauth_client.py"

     

       117
       117
       +
           "tests/client/test_openapi_experimental.py"

     

       118
       118
       +
           "tests/client/test_openapi_legacy.py"

     

       108
       119
        
           "tests/client/test_sse.py"

     

       109
       120
        
           "tests/client/test_streamable_http.py"

     

       110
       110
       -
           "tests/server/http/test_http_dependencies.py"

     

       121
       121
       +
           "tests/server/auth/test_jwt_provider.py"

     

       111
       122
        
           "tests/server/http/test_http_dependencies.py"

     

       112
       123
        
         ];

     

       113
       124

+53

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

···

       1
       1
       +
       {

     

       2
       2
       +
         lib,

     

       3
       3
       +
         stdenv,

     

       4
       4
       +
         buildPythonPackage,

     

       5
       5
       +
         libopaque,

     

       6
       6
       +
         setuptools,

     

       7
       7
       +
         pysodium,

     

       8
       8
       +
         python,

     

       9
       9
       +
       }:

     

       10
       10
       +
       

     

       11
       11
       +
       buildPythonPackage rec {

     

       12
       12
       +
         pname = "opaque";

     

       13
       13
       +
         pyproject = true;

     

       14
       14
       +
       

     

       15
       15
       +
         inherit (libopaque)

     

       16
       16
       +
           version

     

       17
       17
       +
           src

     

       18
       18
       +
           ;

     

       19
       19
       +
       

     

       20
       20
       +
         sourceRoot = "${src.name}/python";

     

       21
       21
       +
       

     

       22
       22
       +
         postPatch =

     

       23
       23
       +
           let

     

       24
       24
       +
             soext = stdenv.hostPlatform.extensions.sharedLibrary;

     

       25
       25
       +
           in

     

       26
       26
       +
           ''

     

       27
       27
       +
             substituteInPlace ./opaque/__init__.py --replace-fail \

     

       28
       28
       +
               "ctypes.util.find_library('opaque') or ctypes.util.find_library('libopaque')" "'${lib.getLib libopaque}/lib/libopaque${soext}'"

     

       29
       29
       +
           '';

     

       30
       30
       +
       

     

       31
       31
       +
         build-system = [ setuptools ];

     

       32
       32
       +
       

     

       33
       33
       +
         dependencies = [ pysodium ];

     

       34
       34
       +
       

     

       35
       35
       +
         pythonImportsCheck = [ "opaque" ];

     

       36
       36
       +
       

     

       37
       37
       +
         checkPhase = ''

     

       38
       38
       +
           runHook preCheck

     

       39
       39
       +
       

     

       40
       40
       +
           ${python.interpreter} test/simple.py

     

       41
       41
       +
       

     

       42
       42
       +
           runHook postCheck

     

       43
       43
       +
         '';

     

       44
       44
       +
       

     

       45
       45
       +
         meta = {

     

       46
       46
       +
           inherit (libopaque.meta)

     

       47
       47
       +
             description

     

       48
       48
       +
             homepage

     

       49
       49
       +
             license

     

       50
       50
       +
             teams

     

       51
       51
       +
             ;

     

       52
       52
       +
         };

     

       53
       53
       +
       }

+39

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

···

       1
       1
       +
       {

     

       2
       2
       +
         lib,

     

       3
       3
       +
         buildPythonPackage,

     

       4
       4
       +
         fetchPypi,

     

       5
       5
       +
         cmake,

     

       6
       6
       +
         setuptools,

     

       7
       7
       +
         wheel,

     

       8
       8
       +
       }:

     

       9
       9
       +
       

     

       10
       10
       +
       buildPythonPackage rec {

     

       11
       11
       +
         pname = "opencc";

     

       12
       12
       +
         version = "1.1.9";

     

       13
       13
       +
         format = "setuptools";

     

       14
       14
       +
       

     

       15
       15
       +
         src = fetchPypi {

     

       16
       16
       +
           pname = "opencc";

     

       17
       17
       +
           inherit version;

     

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

     

       19
       19
       +
         };

     

       20
       20
       +
       

     

       21
       21
       +
         nativeBuildInputs = [

     

       22
       22
       +
           cmake

     

       23
       23
       +
           setuptools

     

       24
       24
       +
           wheel

     

       25
       25
       +
         ];

     

       26
       26
       +
       

     

       27
       27
       +
         dontUseCmakeConfigure = true;

     

       28
       28
       +
       

     

       29
       29
       +
         pythonImportsCheck = [

     

       30
       30
       +
           "opencc"

     

       31
       31
       +
         ];

     

       32
       32
       +
       

     

       33
       33
       +
         meta = {

     

       34
       34
       +
           description = "Python bindings for OpenCC (Conversion between Traditional and Simplified Chinese)";

     

       35
       35
       +
           homepage = "https://github.com/BYVoid/OpenCC";

     

       36
       36
       +
           license = lib.licenses.asl20;

     

       37
       37
       +
           maintainers = with lib.maintainers; [ siraben ];

     

       38
       38
       +
         };

     

       39
       39
       +
       }

+2 -2

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

···

       12
       12
        
       

     

       13
       13
        
       buildPythonPackage rec {

     

       14
       14
        
         pname = "osc";

     

       15
       15
       -
         version = "1.9.1";

     

       15
       15
       +
         version = "1.19.1";

     

       16
       16
        
         format = "setuptools";

     

       17
       17
        
       

     

       18
       18
        
         src = fetchFromGitHub {

     

       19
       19
        
           owner = "openSUSE";

     

       20
       20
        
           repo = "osc";

     

       21
       21
        
           rev = version;

     

       22
       22
       -
           hash = "sha256-03EDarU7rmsiE96IYHXFuPtD8nWur0qwj8NDzSj8OX0=";

     

       22
       22
       +
           hash = "sha256-klPO873FwQOf4DCTuDd86vmGLI4ep9xgS6c+HasJv0Q=";

     

       23
       23
        
         };

     

       24
       24
        
       

     

       25
       25
        
         buildInputs = [ bashInteractive ]; # needed for bash-completion helper

+1

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

···

       84
       84
        
         env.CIBUILDWHEEL = "1";

     

       85
       85
        
       

     

       86
       86
        
         pythonRelaxDeps = [

     

       87
       87
       +
           "cachetools"

     

       87
       88
        
           "rich"

     

       88
       89
        
         ];

     

       89
       90

+11 -16

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

···

       1
       1
        
       {

     

       2
       2
        
         lib,

     

       3
       3
       +
         stdenv,

     

       3
       4
        
         buildPythonPackage,

     

       4
       5
        
         fetchFromGitHub,

     

       5
       5
       -
         fetchpatch,

     

       6
       6
       +
       

     

       7
       7
       +
         # build-system

     

       8
       8
       +
         setuptools-scm,

     

       9
       9
       +
       

     

       10
       10
       +
         # dependencies

     

       6
       11
        
         capstone,

     

       7
       12
        
         cmsis-pack-manager,

     

       8
       13
        
         colorama,

     
···

       17
       22
        
         pylink-square,

     

       18
       23
        
         pyusb,

     

       19
       24
        
         pyyaml,

     

       20
       20
       -
         setuptools-scm,

     

       21
       25
        
         typing-extensions,

     

       22
       22
       -
         stdenv,

     

       23
       26
        
         hidapi,

     

       27
       27
       +
       

     

       28
       28
       +
         # tests

     

       24
       29
        
         pytestCheckHook,

     

       25
       30
        
       }:

     

       26
       31
        
       

     
···

       36
       41
        
           hash = "sha256-4fdVcTNH125e74S3mA/quuDun17ntGCazX6CV+obUGc=";

     

       37
       42
        
         };

     

       38
       43
        
       

     

       39
       39
       -
         patches = [

     

       40
       40
       -
           # https://github.com/pyocd/pyOCD/pull/1332

     

       41
       41
       -
           # merged into develop

     

       42
       42
       -
           (fetchpatch {

     

       43
       43
       -
             name = "libusb-package-optional.patch";

     

       44
       44
       -
             url = "https://github.com/pyocd/pyOCD/commit/0b980cf253e3714dd2eaf0bddeb7172d14089649.patch";

     

       45
       45
       -
             hash = "sha256-B2+50VntcQELeakJbCeJdgI1iBU+h2NkXqba+LRYa/0=";

     

       46
       46
       -
           })

     

       47
       47
       -
         ];

     

       48
       48
       -
       

     

       49
       44
        
         pythonRelaxDeps = [ "capstone" ];

     

       50
       45
        
         pythonRemoveDeps = [ "libusb-package" ];

     

       51
       46
        
       

     
···

       80
       75
        
       

     

       81
       76
        
         nativeCheckInputs = [ pytestCheckHook ];

     

       82
       77
        
       

     

       83
       83
       -
         meta = with lib; {

     

       78
       78
       +
         meta = {

     

       84
       79
        
           changelog = "https://github.com/pyocd/pyOCD/releases/tag/${src.tag}";

     

       85
       80
        
           description = "Python library for programming and debugging Arm Cortex-M microcontrollers";

     

       86
       81
        
           downloadPage = "https://github.com/pyocd/pyOCD";

     

       87
       82
        
           homepage = "https://pyocd.io";

     

       88
       88
       -
           license = licenses.asl20;

     

       89
       89
       -
           maintainers = with maintainers; [

     

       83
       83
       +
           license = lib.licenses.asl20;

     

       84
       84
       +
           maintainers = with lib.maintainers; [

     

       90
       85
        
             frogamic

     

       91
       86
        
             sbruder

     

       92
       87
        
           ];

+2 -2

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

···

       12
       12
        
       

     

       13
       13
        
       buildPythonPackage rec {

     

       14
       14
        
         pname = "pytouchlinesl";

     

       15
       15
       -
         version = "0.4.0";

     

       15
       15
       +
         version = "0.5.0";

     

       16
       16
        
         pyproject = true;

     

       17
       17
        
       

     

       18
       18
        
         disabled = pythonOlder "3.10";

     
···

       21
       21
        
           owner = "jnsgruk";

     

       22
       22
        
           repo = "pytouchlinesl";

     

       23
       23
        
           tag = version;

     

       24
       24
       -
           hash = "sha256-hrC5cBtAU9P9VaRIoUKDx5x4KwUN6mO/JwEZrsnYB0s=";

     

       24
       24
       +
           hash = "sha256-R5XgH8A9P5KcjQL/f+E189A+iRVUIbWsmyRrnfV43v4=";

     

       25
       25
        
         };

     

       26
       26
        
       

     

       27
       27
        
         build-system = [ setuptools ];

+17 -17

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

···

       64
       64
        
       

     

       65
       65
        
       let

     

       66
       66
        
         pname = "ray";

     

       67
       67
       -
         version = "2.48.0";

     

       67
       67
       +
         version = "2.49.0";

     

       68
       68
        
       in

     

       69
       69
        
       buildPythonPackage rec {

     

       70
       70
        
         inherit pname version;

     
···

       85
       85
        
             # Results are in ./ray-hashes.nix

     

       86
       86
        
             hashes = {

     

       87
       87
        
               x86_64-linux = {

     

       88
       88
       -
                 cp310 = "sha256-ZJ7ZRC3C05E1xZO2zww46DVRcLkmcjZat6PLyVjEJjQ=";

     

       89
       89
       -
                 cp311 = "sha256-RtS0KlhJLex5yq0tViNEaJpPmagoruqBGgzSzWU1U+8=";

     

       90
       90
       -
                 cp312 = "sha256-pC7TtkD0tZmj/IBnyD7mBJfA8D0HDXp98Co4j6F6VGs=";

     

       91
       91
       -
                 cp313 = "sha256-JeS3n8yPhJ1y2xrMTwPzcAjFwLdF32PYowzTVna2VF4=";

     

       88
       88
       +
                 cp310 = "sha256-bFQKbfqOWC4HJQV8E3JFzNP6DWl7R2SFMxdvWoqzCjA=";

     

       89
       89
       +
                 cp311 = "sha256-Ja5MII3Hi0plPDEcsmuTx0QB5nYqGTztX6uqkQqBfYE=";

     

       90
       90
       +
                 cp312 = "sha256-lShdI6MDsXTQcKaz6ocj6dq/B6QUegHLkzHV6t+MoLI=";

     

       91
       91
       +
                 cp313 = "sha256-42mZ1Pgx8vIcqPtWnwWY+4DKjawPiDbErHXM2ltVi/s=";

     

       92
       92
        
               };

     

       93
       93
        
               aarch64-linux = {

     

       94
       94
       -
                 cp310 = "sha256-+CCVC8RNewAMIjNC9cgAycCOf9iVJCARJTiOohHKrRo=";

     

       95
       95
       -
                 cp311 = "sha256-JKcPQW7AvhS5dfFgBEgFzLSMxrxQ3mMpg+uPCo4WaCs=";

     

       96
       96
       -
                 cp312 = "sha256-8c8z0mAxb5L3dVgYXxw2/DVQbXbuf9/tn1tw+cS9un8=";

     

       97
       97
       -
                 cp313 = "sha256-Yi5rzbeNmAQNh76pTmXQu2zMCuG0MpTGvWn1Qr8o4JI=";

     

       94
       94
       +
                 cp310 = "sha256-jFWnpGKgzese1Y+jYQ9S46KEzk4MVVZjWb0RWKloP0Q=";

     

       95
       95
       +
                 cp311 = "sha256-KnXS/YvKsahQkeow5ZMsXiiXxxIq4j+SH0+v7sIsOCg=";

     

       96
       96
       +
                 cp312 = "sha256-NjVn9WES86FRjs2NDjoM5PBTcFzI9NQ+kzyvafs1lxw=";

     

       97
       97
       +
                 cp313 = "sha256-/Wu+DBhvHWpJ31NTKyGSH9Bf+ZPLVG9mW3GAmGIPY8U=";

     

       98
       98
        
               };

     

       99
       99
        
               x86_64-darwin = {

     

       100
       100
       -
                 cp310 = "sha256-M72kdTrQrNK1JMkVgInUNIbNRMxZ/pcEZkNbwpaP3i0=";

     

       101
       101
       -
                 cp311 = "sha256-uUUA/i0X5JH+LpvUo79i3yF+IajyhFAzw1PU0uokD3M=";

     

       102
       102
       -
                 cp312 = "sha256-Wm9XEm6sndMoYongfpHoewVHkvlpi298yriLYkgWtUI=";

     

       103
       103
       -
                 cp313 = "sha256-V0K3KlFK/l1g9BMwIAzVCDduFsZQ9pYuYjN6pILWoMY=";

     

       100
       100
       +
                 cp310 = "sha256-6Qjm97RkKdJvRZRXlFgpiETRpIXCiM/liRT6eilP06Q=";

     

       101
       101
       +
                 cp311 = "sha256-5CpBh6kOiXr7lVF8uKpPwMJHGL1Ci97AsmCqLRjs5sg=";

     

       102
       102
       +
                 cp312 = "sha256-FvsQ5YuuSDECZ16Cnq0afQpHjcVfmf8GuDKnicogi6k=";

     

       103
       103
       +
                 cp313 = "sha256-LhOphUj78ujX8JY8YK/1HZtT01naDO9QoHGpUMT85Uo=";

     

       104
       104
        
               };

     

       105
       105
        
               aarch64-darwin = {

     

       106
       106
       -
                 cp310 = "sha256-bKK5zkWtNgy+KZaYL7Imkez+ZVPsj5eiVIKV8PlqrHg=";

     

       107
       107
       -
                 cp311 = "sha256-S5uSrCljX1Ve80E0fZpj2/ArfZRjRyOa88CeNkvEXPg=";

     

       108
       108
       -
                 cp312 = "sha256-jeeZ87CJb0jTBtXkoE/GA3oIxJXUX5x5k1NE5Wk+PPg=";

     

       109
       109
       -
                 cp313 = "sha256-p6bYMNncWui7FW/N6aGtq39O2wBPA5GKck2IXs64Jk0=";

     

       106
       106
       +
                 cp310 = "sha256-seRUvxTQCGfaXslF4L4IfWhFfyQbqmClDLccBBosTfw=";

     

       107
       107
       +
                 cp311 = "sha256-VKipsP5qnLFagvNxwufWhCD540/+OKi+PD3UvlQFHGY=";

     

       108
       108
       +
                 cp312 = "sha256-+UOpwq4EljaxJqGUBH/fkQEGCpmF0dthSxeycGH46fM=";

     

       109
       109
       +
                 cp313 = "sha256-9CDvy2n6ZDAf8su3YR10rwEguu6OhAhtjzuV6BVTD5M=";

     

       110
       110
        
               };

     

       111
       111
        
             };

     

       112
       112
        
           in

+4

pkgs/development/python-modules/spsdk-pyocd/default.nix

···

       35
       35
        
           setuptools

     

       36
       36
        
         ];

     

       37
       37
        
       

     

       38
       38
       +
         pythonRelaxDeps = [

     

       39
       39
       +
           "pyocd"

     

       40
       40
       +
         ];

     

       41
       41
       +
       

     

       38
       42
        
         dependencies = [

     

       39
       43
        
           pyocd

     

       40
       44
        
         ];

+6

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

···

       39
       39
        
         x690,

     

       40
       40
        
       

     

       41
       41
        
         # tests

     

       42
       42
       +
         cookiecutter,

     

       42
       43
        
         ipykernel,

     

       43
       44
        
         pytest-notebook,

     

       44
       45
        
         pytestCheckHook,

     
···

       95
       96
        
           click-command-tree

     

       96
       97
        
           click-option-group

     

       97
       98
        
           colorama

     

       99
       99
       +
           cookiecutter

     

       98
       100
        
           crcmod

     

       99
       101
        
           cryptography

     

       100
       102
        
           deepmerge

     
···

       122
       124
        
         pythonImportsCheck = [ "spsdk" ];

     

       123
       125
        
       

     

       124
       126
        
         nativeCheckInputs = [

     

       127
       127
       +
           cookiecutter

     

       125
       128
        
           ipykernel

     

       126
       129
        
           pytest-notebook

     

       127
       130
        
           pytestCheckHook

     
···

       134
       137
        
         disabledTests = [

     

       135
       138
        
           # Missing rotk private key

     

       136
       139
        
           "test_general_notebooks"

     

       140
       140
       +
       

     

       141
       141
       +
           # Attempts to access /run

     

       142
       142
       +
           "test_nxpimage_famode_export_cli"

     

       137
       143
        
         ];

     

       138
       144
        
       

     

       139
       145
        
         meta = {

+1 -7

pkgs/development/python-modules/torch/source/default.nix

···

       72
       72
        
         #          (dependencies without cuda support).

     

       73
       73
        
         #          Instead we should rely on overlays and nixpkgsFun.

     

       74
       74
        
         # (@SomeoneSerge)

     

       75
       75
       -
         _tritonEffective ?

     

       76
       76
       -
           if cudaSupport then

     

       77
       77
       -
             triton-cuda

     

       78
       78
       -
           else if rocmSupport then

     

       79
       79
       -
             rocmPackages.triton

     

       80
       80
       -
           else

     

       81
       81
       -
             triton,

     

       75
       75
       +
         _tritonEffective ? if cudaSupport then triton-cuda else triton,

     

       82
       76
        
         triton-cuda,

     

       83
       77
        
       

     

       84
       78
        
         # Disable MKLDNN on aarch64-darwin, it negatively impacts performance,

-28

pkgs/development/python-modules/triton/0002-nvidia-amd-driver-short-circuit-before-ldconfig.patch

···

       1
       1
       -
       diff --git a/third_party/amd/backend/driver.py b/third_party/amd/backend/driver.py

     

       2
       2
       -
       index ca712f904..0961d2dda 100644

     

       3
       3
       -
       --- a/third_party/amd/backend/driver.py

     

       4
       4
       -
       +++ b/third_party/amd/backend/driver.py

     

       5
       5
       -
       @@ -79,6 +79,9 @@ def _get_path_to_hip_runtime_dylib():

     

       6
       6
       -
                    return mmapped_path

     

       7
       7
       -
                raise RuntimeError(f"memory mapped '{mmapped_path}' in process does not point to a valid {lib_name}")

     

       8
       8
       -
        

     

       9
       9
       -
       +    if os.path.isdir("@libhipDir@"):

     

       10
       10
       -
       +        return ["@libhipDir@"]

     

       11
       11
       -
       +

     

       12
       12
       -
            paths = []

     

       13
       13
       -
        

     

       14
       14
       -
            import site

     

       15
       15
       -
       diff --git a/third_party/nvidia/backend/driver.py b/third_party/nvidia/backend/driver.py

     

       16
       16
       -
       index d088ec092..625de2db8 100644

     

       17
       17
       -
       --- a/third_party/nvidia/backend/driver.py

     

       18
       18
       -
       +++ b/third_party/nvidia/backend/driver.py

     

       19
       19
       -
       @@ -23,6 +23,9 @@ def libcuda_dirs():

     

       20
       20
       -
            if env_libcuda_path:

     

       21
       21
       -
                return [env_libcuda_path]

     

       22
       22
       -
        

     

       23
       23
       -
       +    if os.path.exists("@libcudaStubsDir@"):

     

       24
       24
       -
       +        return ["@libcudaStubsDir@"]

     

       25
       25
       -
       +

     

       26
       26
       -
            libs = subprocess.check_output(["/sbin/ldconfig", "-p"]).decode()

     

       27
       27
       -
            # each line looks like the following:

     

       28
       28
       -
            # libcuda.so.1 (libc6,x86-64) => /lib/x86_64-linux-gnu/libcuda.so.1

+14

pkgs/development/python-modules/triton/0002-nvidia-driver-short-circuit-before-ldconfig.patch

···

       1
       1
       +
       diff --git a/third_party/nvidia/backend/driver.py b/third_party/nvidia/backend/driver.py

     

       2
       2
       +
       index d088ec092..625de2db8 100644

     

       3
       3
       +
       --- a/third_party/nvidia/backend/driver.py

     

       4
       4
       +
       +++ b/third_party/nvidia/backend/driver.py

     

       5
       5
       +
       @@ -23,6 +23,9 @@ def libcuda_dirs():

     

       6
       6
       +
            if env_libcuda_path:

     

       7
       7
       +
                return [env_libcuda_path]

     

       8
       8
       +
        

     

       9
       9
       +
       +    if os.path.exists("@libcudaStubsDir@"):

     

       10
       10
       +
       +        return ["@libcudaStubsDir@"]

     

       11
       11
       +
       +

     

       12
       12
       +
            libs = subprocess.check_output(["/sbin/ldconfig", "-p"]).decode()

     

       13
       13
       +
            # each line looks like the following:

     

       14
       14
       +
            # libcuda.so.1 (libc6,x86-64) => /lib/x86_64-linux-gnu/libcuda.so.1

+60

pkgs/development/python-modules/triton/0005-amd-search-env-paths.patch

···

       1
       1
       +
       From 9e4e58b647c17c5fa098c8a74e221f88d3cb1a43 Mon Sep 17 00:00:00 2001

     

       2
       2
       +
       From: Luna Nova <git@lunnova.dev>

     

       3
       3
       +
       Date: Sun, 24 Aug 2025 07:41:30 -0700

     

       4
       4
       +
       Subject: [PATCH] [AMD] Search HIP_PATH, hipconfig, and ROCM_PATH for

     

       5
       5
       +
        libamdhip64

     

       6
       6
       +
       

     

       7
       7
       +
       Search for libamdhip64 from HIP_PATH env var, hipconfig --path output,

     

       8
       8
       +
       and ROCM_PATH before looking in system-wide ldconfig or /opt/rocm.

     

       9
       9
       +
       

     

       10
       10
       +
       The system-wide ROCm path isn't guaranteed to be where the ROCm

     

       11
       11
       +
       install we're building against is located, so follow typical ROCm

     

       12
       12
       +
       lib behavior and look under env paths first.

     

       13
       13
       +
       

     

       14
       14
       +
       This is especially important for non-FHS distros like NixOS

     

       15
       15
       +
       where /opt/rocm never exists, but may be useful in more

     

       16
       16
       +
       typical distros if multiple ROCm installs are present

     

       17
       17
       +
       to ensure the right libamdhip64.so is picked up.

     

       18
       18
       +
       ---

     

       19
       19
       +
        third_party/amd/backend/driver.py | 28 ++++++++++++++++++++++++++++

     

       20
       20
       +
        1 file changed, 28 insertions(+)

     

       21
       21
       +
       

     

       22
       22
       +
       diff --git a/third_party/amd/backend/driver.py b/third_party/amd/backend/driver.py

     

       23
       23
       +
       index af8e1a5c8097..57b0f7388c60 100644

     

       24
       24
       +
       --- a/third_party/amd/backend/driver.py

     

       25
       25
       +
       +++ b/third_party/amd/backend/driver.py

     

       26
       26
       +
       @@ -110,6 +110,34 @@ def _get_path_to_hip_runtime_dylib():

     

       27
       27
       +
                        return f

     

       28
       28
       +
                    paths.append(f)

     

       29
       29
       +
        

     

       30
       30
       +
       +    # HIP_PATH should point to HIP SDK root if set

     

       31
       31
       +
       +    env_hip_path = os.getenv("HIP_PATH")

     

       32
       32
       +
       +    if env_hip_path:

     

       33
       33
       +
       +        hip_lib_path = os.path.join(env_hip_path, "lib", lib_name)

     

       34
       34
       +
       +        if os.path.exists(hip_lib_path):

     

       35
       35
       +
       +            return hip_lib_path

     

       36
       36
       +
       +        paths.append(hip_lib_path)

     

       37
       37
       +
       +

     

       38
       38
       +
       +    # if available, `hipconfig --path` prints the HIP SDK root

     

       39
       39
       +
       +    try:

     

       40
       40
       +
       +        hip_root = subprocess.check_output(["hipconfig", "--path"]).decode().strip()

     

       41
       41
       +
       +        if hip_root:

     

       42
       42
       +
       +            hip_lib_path = os.path.join(hip_root, "lib", lib_name)

     

       43
       43
       +
       +            if os.path.exists(hip_lib_path):

     

       44
       44
       +
       +                return hip_lib_path

     

       45
       45
       +
       +            paths.append(hip_lib_path)

     

       46
       46
       +
       +    except (subprocess.CalledProcessError, FileNotFoundError):

     

       47
       47
       +
       +        # hipconfig may not be available

     

       48
       48
       +
       +        pass

     

       49
       49
       +
       +

     

       50
       50
       +
       +    # ROCm lib dir based on env var

     

       51
       51
       +
       +    env_rocm_path = os.getenv("ROCM_PATH")

     

       52
       52
       +
       +    if env_rocm_path:

     

       53
       53
       +
       +        rocm_lib_path = os.path.join(env_rocm_path, "lib", lib_name)

     

       54
       54
       +
       +        if os.path.exists(rocm_lib_path):

     

       55
       55
       +
       +            return rocm_lib_path

     

       56
       56
       +
       +        paths.append(rocm_lib_path)

     

       57
       57
       +
       +

     

       58
       58
       +
            # Afterwards try to search the loader dynamic library resolution paths.

     

       59
       59
       +
            libs = subprocess.check_output(["/sbin/ldconfig", "-p"]).decode(errors="ignore")

     

       60
       60
       +
            # each line looks like the following:

+52 -3

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

···

       23
       23
        
         torchWithRocm,

     

       24
       24
        
         zlib,

     

       25
       25
        
         cudaSupport ? config.cudaSupport,

     

       26
       26
       -
         rocmSupport ? config.rocmSupport,

     

       26
       26
       +
         runCommand,

     

       27
       27
        
         rocmPackages,

     

       28
       28
        
         triton,

     

       29
       29
        
       }:

     
···

       45
       45
        
           (replaceVars ./0001-_build-allow-extra-cc-flags.patch {

     

       46
       46
        
             ccCmdExtraFlags = "-Wl,-rpath,${addDriverRunpath.driverLink}/lib";

     

       47
       47
        
           })

     

       48
       48
       -
           (replaceVars ./0002-nvidia-amd-driver-short-circuit-before-ldconfig.patch {

     

       49
       49
       -
             libhipDir = if rocmSupport then "${lib.getLib rocmPackages.clr}/lib" else null;

     

       48
       48
       +
           (replaceVars ./0002-nvidia-driver-short-circuit-before-ldconfig.patch {

     

       50
       49
        
             libcudaStubsDir =

     

       51
       50
        
               if cudaSupport then "${lib.getOutput "stubs" cudaPackages.cuda_cudart}/lib/stubs" else null;

     

       52
       51
        
           })

     

       52
       52
       +
           # Upstream PR: https://github.com/triton-lang/triton/pull/7959

     

       53
       53
       +
           ./0005-amd-search-env-paths.patch

     

       53
       54
        
         ]

     

       54
       55
        
         ++ lib.optionals cudaSupport [

     

       55
       56
        
           (replaceVars ./0003-nvidia-cudart-a-systempath.patch {

     
···

       81
       82
        
             substituteInPlace cmake/AddTritonUnitTest.cmake \

     

       82
       83
        
               --replace-fail "include(\''${PROJECT_SOURCE_DIR}/unittest/googletest.cmake)" ""\

     

       83
       84
        
               --replace-fail "include(GoogleTest)" "find_package(GTest REQUIRED)"

     

       85
       85
       +
           ''

     

       86
       86
       +
           # Don't use FHS path for ROCm LLD

     

       87
       87
       +
           # Remove this after `[AMD] Use lld library API #7548` makes it into a release

     

       88
       88
       +
           + ''

     

       89
       89
       +
             substituteInPlace third_party/amd/backend/compiler.py \

     

       90
       90
       +
               --replace-fail 'lld = Path("/opt/rocm/llvm/bin/ld.lld")' \

     

       91
       91
       +
               "import os;lld = Path(os.getenv('HIP_PATH', '/opt/rocm/')"' + "/llvm/bin/ld.lld")'

     

       84
       92
        
           '';

     

       85
       93
        
       

     

       86
       94
        
         build-system = [ setuptools ];

     
···

       204
       212
        
         passthru.tests = {

     

       205
       213
        
           # Ultimately, torch is our test suite:

     

       206
       214
        
           inherit torchWithRocm;

     

       215
       215
       +
       

     

       216
       216
       +
           # Test that _get_path_to_hip_runtime_dylib works when ROCm is available at runtime

     

       217
       217
       +
           rocm-libamdhip64-path =

     

       218
       218
       +
             runCommand "triton-rocm-libamdhip64-path-test"

     

       219
       219
       +
               {

     

       220
       220
       +
                 buildInputs = [

     

       221
       221
       +
                   triton

     

       222
       222
       +
                   python

     

       223
       223
       +
                   rocmPackages.clr

     

       224
       224
       +
                 ];

     

       225
       225
       +
               }

     

       226
       226
       +
               ''

     

       227
       227
       +
                 python -c "

     

       228
       228
       +
                 import os

     

       229
       229
       +
                 import triton

     

       230
       230
       +
                 path = triton.backends.amd.driver._get_path_to_hip_runtime_dylib()

     

       231
       231
       +
                 print(f'libamdhip64 path: {path}')

     

       232
       232
       +
                 assert os.path.exists(path)

     

       233
       233
       +
                 " && touch $out

     

       234
       234
       +
               '';

     

       235
       235
       +
       

     

       236
       236
       +
           # Test that path_to_rocm_lld works when ROCm is available at runtime

     

       237
       237
       +
           # Remove this after `[AMD] Use lld library API #7548` makes it into a release

     

       238
       238
       +
           rocm-lld-path =

     

       239
       239
       +
             runCommand "triton-rocm-lld-test"

     

       240
       240
       +
               {

     

       241
       241
       +
                 buildInputs = [

     

       242
       242
       +
                   triton

     

       243
       243
       +
                   python

     

       244
       244
       +
                   rocmPackages.clr

     

       245
       245
       +
                 ];

     

       246
       246
       +
               }

     

       247
       247
       +
               ''

     

       248
       248
       +
                 python -c "

     

       249
       249
       +
                 import os

     

       250
       250
       +
                 import triton

     

       251
       251
       +
                 path = triton.backends.backends['amd'].compiler.path_to_rocm_lld()

     

       252
       252
       +
                 print(f'ROCm LLD path: {path}')

     

       253
       253
       +
                 assert os.path.exists(path)

     

       254
       254
       +
                 " && touch $out

     

       255
       255
       +
               '';

     

       207
       256
        
       

     

       208
       257
        
           # Test as `nix run -f "<nixpkgs>" python3Packages.triton.tests.axpy-cuda`

     

       209
       258
        
           # or, using `programs.nix-required-mounts`, as `nix build -f "<nixpkgs>" python3Packages.triton.tests.axpy-cuda.gpuCheck`

+13

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

···

       2
       2
        
         lib,

     

       3
       3
        
         buildPythonPackage,

     

       4
       4
        
         fetchPypi,

     

       5
       5
       +
         fetchpatch,

     

       5
       6
        
         pythonOlder,

     

       6
       7
        
         click,

     

       7
       8
        
         click-log,

     
···

       37
       38
        
           inherit pname version;

     

       38
       39
        
           hash = "sha256-5DeFH+uYXew1RGVPj5z23RCbCwP34ZlWCGYDCS/+so8=";

     

       39
       40
        
         };

     

       41
       41
       +
       

     

       42
       42
       +
         patches = [

     

       43
       43
       +
           (

     

       44
       44
       +
             # Fix event_loop missing

     

       45
       45
       +
             # TODO: remove it after vdirsyncer release 0.19.4

     

       46
       46
       +
             fetchpatch {

     

       47
       47
       +
               # https://github.com/pimutils/vdirsyncer/pull/1185

     

       48
       48
       +
               url = "https://github.com/pimutils/vdirsyncer/commit/164559ad7a95ed795ce4ae8d9b287bd27704742d.patch";

     

       49
       49
       +
               hash = "sha256-nUGvkBnHr8nVPpBuhQ5GjaRs3QSxokdZUEIsOrQ+lpo=";

     

       50
       50
       +
             }

     

       51
       51
       +
           )

     

       52
       52
       +
         ];

     

       40
       53
        
       

     

       41
       54
        
         nativeBuildInputs = [

     

       42
       55
        
           setuptools

+4 -15

pkgs/development/rocm-modules/6/default.nix

···

       264
       264
        
             );

     

       265
       265
        
             mpi = self.openmpi;

     

       266
       266
        
       

     

       267
       267
       -
             triton-llvm = triton-llvm.overrideAttrs {

     

       268
       268
       -
               src = fetchFromGitHub {

     

       269
       269
       -
                 owner = "llvm";

     

       270
       270
       -
                 repo = "llvm-project";

     

       271
       271
       -
                 # make sure this matches triton llvm rel branch hash for now

     

       272
       272
       -
                 # https://github.com/triton-lang/triton/blob/release/3.2.x/cmake/llvm-hash.txt

     

       273
       273
       -
                 rev = "86b69c31642e98f8357df62c09d118ad1da4e16a";

     

       274
       274
       -
                 hash = "sha256-W/mQwaLGx6/rIBjdzUTIbWrvGjdh7m4s15f70fQ1/hE=";

     

       275
       275
       -
               };

     

       276
       276
       -
               pname = "triton-llvm-rocm";

     

       277
       277
       -
               patches = [ ]; # FIXME: https://github.com/llvm/llvm-project//commit/84837e3cc1cf17ed71580e3ea38299ed2bfaa5f6.patch doesn't apply, may need to rebase

     

       278
       278
       -
             };

     

       279
       279
       -
       

     

       280
       280
       -
             triton = pyPackages.callPackage ./triton { rocmPackages = self; };

     

       281
       281
       -
       

     

       282
       267
        
             ## Meta ##

     

       283
       268
        
             # Emulate common ROCm meta layout

     

       284
       269
        
             # These are mainly for users. I strongly suggest NOT using these in nixpkgs derivations

     
···

       454
       439
        
             };

     

       455
       440
        
           }

     

       456
       441
        
           // lib.optionalAttrs config.allowAliases {

     

       442
       442
       +
             triton = throw ''

     

       443
       443
       +
               'rocmPackages.triton' has been removed. Please use python3Packages.triton

     

       444
       444
       +
             ''; # Added 2025-08-24

     

       445
       445
       +
       

     

       457
       446
        
             rocm-thunk = throw ''

     

       458
       447
        
               'rocm-thunk' has been removed. It's now part of the ROCm runtime.

     

       459
       448
        
             ''; # Added 2025-3-16

-56

pkgs/development/rocm-modules/6/triton/default.nix

···

       1
       1
       -
       {

     

       2
       2
       -
         triton-no-cuda,

     

       3
       3
       -
         rocmPackages,

     

       4
       4
       -
         fetchFromGitHub,

     

       5
       5
       -
       }:

     

       6
       6
       -
       (triton-no-cuda.override (_old: {

     

       7
       7
       -
         inherit rocmPackages;

     

       8
       8
       -
         rocmSupport = true;

     

       9
       9
       -
         stdenv = rocmPackages.llvm.rocmClangStdenv;

     

       10
       10
       -
         llvm = rocmPackages.triton-llvm;

     

       11
       11
       -
       })).overridePythonAttrs

     

       12
       12
       -
         (old: {

     

       13
       13
       -
           doCheck = false;

     

       14
       14
       -
           stdenv = rocmPackages.llvm.rocmClangStdenv;

     

       15
       15
       -
           version = "3.2.0";

     

       16
       16
       -
           src = fetchFromGitHub {

     

       17
       17
       -
             owner = "triton-lang";

     

       18
       18
       -
             repo = "triton";

     

       19
       19
       -
             rev = "9641643da6c52000c807b5eeed05edaec4402a67"; # "release/3.2.x";

     

       20
       20
       -
             hash = "sha256-V1lpARwOLn28ZHfjiWR/JJWGw3MB34c+gz6Tq1GOVfo=";

     

       21
       21
       -
           };

     

       22
       22
       -
           buildInputs = old.buildInputs ++ [

     

       23
       23
       -
             rocmPackages.clr

     

       24
       24
       -
           ];

     

       25
       25
       -
           dontStrip = true;

     

       26
       26
       -
           env = old.env // {

     

       27
       27
       -
             CXXFLAGS = "-O3 -I${rocmPackages.clr}/include -I/build/source/third_party/triton/third_party/nvidia/backend/include";

     

       28
       28
       -
             TRITON_OFFLINE_BUILD = 1;

     

       29
       29
       -
           };

     

       30
       30
       -
           patches = [ ];

     

       31
       31
       -
           postPatch = ''

     

       32
       32
       -
             # Remove nvidia backend so we don't depend on unfree nvidia headers

     

       33
       33
       -
             # when we only want to target ROCm

     

       34
       34
       -
             rm -rf third_party/nvidia

     

       35
       35
       -
             substituteInPlace CMakeLists.txt \

     

       36
       36
       -
               --replace-fail "add_subdirectory(test)" ""

     

       37
       37
       -
             sed -i '/nvidia\|NVGPU\|registerConvertTritonGPUToLLVMPass\|mlir::test::/Id' bin/RegisterTritonDialects.h

     

       38
       38
       -
             sed -i '/TritonTestAnalysis/Id' bin/CMakeLists.txt

     

       39
       39
       -
             substituteInPlace python/setup.py \

     

       40
       40
       -
               --replace-fail 'backends = [*BackendInstaller.copy(["nvidia", "amd"]), *BackendInstaller.copy_externals()]' \

     

       41
       41
       -
               'backends = [*BackendInstaller.copy(["amd"]), *BackendInstaller.copy_externals()]'

     

       42
       42
       -
             find . -type f -exec sed -i 's|[<]cupti.h[>]|"cupti.h"|g' {} +

     

       43
       43
       -
             find . -type f -exec sed -i 's|[<]cuda.h[>]|"cuda.h"|g' {} +

     

       44
       44
       -
             # remove any downloads

     

       45
       45
       -
             substituteInPlace python/setup.py \

     

       46
       46
       -
               --replace-fail "[get_json_package_info()]" "[]"\

     

       47
       47
       -
               --replace-fail "[get_llvm_package_info()]" "[]"\

     

       48
       48
       -
               --replace-fail "curr_version != version" "False"

     

       49
       49
       -
             # Don't fetch googletest

     

       50
       50
       -
             substituteInPlace cmake/AddTritonUnitTest.cmake \

     

       51
       51
       -
               --replace-fail 'include(''${PROJECT_SOURCE_DIR}/unittest/googletest.cmake)' "" \

     

       52
       52
       -
               --replace-fail "include(GoogleTest)" "find_package(GTest REQUIRED)"

     

       53
       53
       -
             substituteInPlace third_party/amd/backend/compiler.py \

     

       54
       54
       -
               --replace-fail '"/opt/rocm/llvm/bin/ld.lld"' "os.environ['ROCM_PATH']"' + "/llvm/bin/ld.lld"'

     

       55
       55
       -
           '';

     

       56
       56
       -
         })

+2 -2

pkgs/development/tools/ocaml/dune/3.nix

···

       14
       14
        
       

     

       15
       15
        
         stdenv.mkDerivation rec {

     

       16
       16
        
           pname = "dune";

     

       17
       17
       -
           version = "3.19.1";

     

       17
       17
       +
           version = "3.20.1";

     

       18
       18
        
       

     

       19
       19
        
           src = fetchurl {

     

       20
       20
        
             url = "https://github.com/ocaml/dune/releases/download/${version}/dune-${version}.tbz";

     

       21
       21
       -
             hash = "sha256-oQOG+YDNqUF9FGVGa+1Q3SrvnJO50GoPf+7tsKFUEVg=";

     

       21
       21
       +
             hash = "sha256-8I6V3igo6JHWiQbkQwtRFwMihSB7W8aE/F1FZS6zDgo=";

     

       22
       22
        
           };

     

       23
       23
        
       

     

       24
       24
        
           nativeBuildInputs = [

+4

pkgs/tools/compression/zstd/default.nix

···

       24
       24
        
         curl,

     

       25
       25
        
         python3Packages,

     

       26
       26
        
         haskellPackages,

     

       27
       27
       +
         testers,

     

       28
       28
       +
         zstd,

     

       27
       29
        
       }:

     

       28
       30
        
       

     

       29
       31
        
       stdenv.mkDerivation rec {

     
···

       126
       128
        
             python-zstd = python3Packages.zstd;

     

       127
       129
        
             haskell-zstd = haskellPackages.zstd;

     

       128
       130
        
             haskell-hs-zstd = haskellPackages.hs-zstd;

     

       131
       131
       +
             pkg-config = testers.hasPkgConfigModules { package = zstd; };

     

       129
       132
        
           };

     

       130
       133
        
         };

     

       131
       134
        
       

     
···

       146
       149
        
           mainProgram = "zstd";

     

       147
       150
        
           platforms = platforms.all;

     

       148
       151
        
           maintainers = with maintainers; [ orivej ];

     

       152
       152
       +
           pkgConfigModules = [ "libzstd" ];

     

       149
       153
        
         };

     

       150
       154
        
       }

+1

pkgs/tools/inputmethods/ibus/default.nix

···

       196
       196
        
           libxkbcommon

     

       197
       197
        
           wayland

     

       198
       198
        
           wayland-protocols

     

       199
       199
       +
           wayland-scanner # For cross, build uses $PKG_CONFIG to look for wayland-scanner

     

       199
       200
        
         ];

     

       200
       201
        
       

     

       201
       202
        
         enableParallelBuilding = true;

+4

pkgs/top-level/python-packages.nix

···

       10775
       10775
        
       

     

       10776
       10776
        
         oocsi = callPackage ../development/python-modules/oocsi { };

     

       10777
       10777
        
       

     

       10778
       10778
       +
         opaque = callPackage ../development/python-modules/opaque { };

     

       10779
       10779
       +
       

     

       10778
       10780
        
         opcua-widgets = callPackage ../development/python-modules/opcua-widgets { };

     

       10779
       10781
        
       

     

       10780
       10782
        
         open-clip-torch = callPackage ../development/python-modules/open-clip-torch { };

     
···

       10812
       10814
        
         };

     

       10813
       10815
        
       

     

       10814
       10816
        
         opencamlib = callPackage ../development/python-modules/opencamlib { };

     

       10817
       10817
       +
       

     

       10818
       10818
       +
         opencc = callPackage ../development/python-modules/opencc { };

     

       10815
       10819
        
       

     

       10816
       10820
        
         opencensus = callPackage ../development/python-modules/opencensus { };

     

       10817
       10821