commit 8b07d4753ce8d2dd1e58826580d9a16766a77762 · pyrox.dev/nixpkgs

+2

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

···

       60
       60
        
       

     

       61
       61
        
       - `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/

     

       62
       62
        
       

     

       63
       63
       +
       - NixOS display manager modules now strictly use tty1, where many of them previously used tty7. Options to configure display managers' VT have been dropped. A configuration with a display manager enabled will not start `getty@tty1.service`, even if the system is forced to boot into `multi-user.target` instead of `graphical.target`.

     

       64
       64
       +
       

     

       63
       65
        
       ## Other Notable Changes {#sec-nixpkgs-release-25.11-notable-changes}

     

       64
       66
        
       

     

       65
       67
        
       <!-- To avoid merge conflicts, consider adding your item at an arbitrary place in the list instead. -->

-3

nixos/lib/systemd-lib.nix

···

       526
       526
        
                 ln -s ${cfg.ctrlAltDelUnit} $out/ctrl-alt-del.target

     

       527
       527
        
                 ln -s rescue.target $out/kbrequest.target

     

       528
       528
        
       

     

       529
       529
       -
                 mkdir -p $out/getty.target.wants/

     

       530
       530
       -
                 ln -s ../autovt@tty1.service $out/getty.target.wants/

     

       531
       531
       -
       

     

       532
       529
        
                 ln -s ../remote-fs.target $out/multi-user.target.wants/

     

       533
       530
        
               ''}

     

       534
       531
        
             ''; # */

+10

nixos/modules/services/display-managers/default.nix

···

       267
       267
        
             in

     

       268
       268
        
             lib.mkIf noDmUsed (lib.mkDefault false);

     

       269
       269
        
       

     

       270
       270
       +
           # We can't just rely on 'Conflicts=autovt@tty1.service' because

     

       271
       271
       +
           # 'switch-to-configuration switch' will start 'autovt@tty1.service'

     

       272
       272
       +
           # and kill us.

     

       273
       273
       +
           systemd.services."autovt@tty1".enable =

     

       274
       274
       +
             lib.mkIf config.systemd.services.display-manager.enable false;

     

       275
       275
       +
       

     

       270
       276
        
           systemd.services.display-manager = {

     

       271
       277
        
             description = "Display Manager";

     

       272
       278
        
             after = [

     

       273
       279
        
               "acpid.service"

     

       274
       280
        
               "systemd-logind.service"

     

       275
       281
        
               "systemd-user-sessions.service"

     

       282
       282
       +
               "autovt@tty1.service"

     

       283
       283
       +
             ];

     

       284
       284
       +
             conflicts = [

     

       285
       285
       +
               "autovt@tty1.service"

     

       276
       286
        
             ];

     

       277
       287
        
             restartIfChanged = false;

     

       278
       288

-3

nixos/modules/services/display-managers/gdm.nix

···

       190
       190
        
           users.groups.gdm.gid = config.ids.gids.gdm;

     

       191
       191
        
       

     

       192
       192
        
           # GDM needs different xserverArgs, presumable because using wayland by default.

     

       193
       193
       -
           services.xserver.tty = null;

     

       194
       193
        
           services.xserver.display = null;

     

       195
       194
        
           services.xserver.verbose = null;

     

       196
       195
        
       

     
···

       260
       259
        
             "rc-local.service"

     

       261
       260
        
             "systemd-machined.service"

     

       262
       261
        
             "systemd-user-sessions.service"

     

       263
       263
       -
             "getty@tty${gdm.initialVT}.service"

     

       264
       262
        
             "plymouth-quit.service"

     

       265
       263
        
             "plymouth-start.service"

     

       266
       264
        
           ];

     

       267
       265
        
           systemd.services.display-manager.conflicts = [

     

       268
       268
       -
             "getty@tty${gdm.initialVT}.service"

     

       269
       266
        
             "plymouth-quit.service"

     

       270
       267
        
           ];

     

       271
       268
        
           systemd.services.display-manager.onFailure = [

+10 -10

nixos/modules/services/display-managers/greetd.nix

···

       6
       6
        
       }:

     

       7
       7
        
       let

     

       8
       8
        
         cfg = config.services.greetd;

     

       9
       9
       -
         tty = "tty${toString cfg.vt}";

     

       9
       9
       +
         tty = "tty1";

     

       10
       10
        
         settingsFormat = pkgs.formats.toml { };

     

       11
       11
        
       in

     

       12
       12
        
       {

     

       13
       13
       +
         imports = [

     

       14
       14
       +
           (lib.mkRemovedOptionModule [

     

       15
       15
       +
             "services"

     

       16
       16
       +
             "greetd"

     

       17
       17
       +
             "vt"

     

       18
       18
       +
           ] "The VT is now fixed to VT1.")

     

       19
       19
       +
         ];

     

       20
       20
       +
       

     

       13
       21
        
         options.services.greetd = {

     

       14
       22
        
           enable = lib.mkEnableOption "greetd, a minimal and flexible login manager daemon";

     

       15
       23
        
       

     
···

       41
       49
        
             '';

     

       42
       50
        
           };

     

       43
       51
        
       

     

       44
       44
       -
           vt = lib.mkOption {

     

       45
       45
       -
             type = lib.types.int;

     

       46
       46
       -
             default = 1;

     

       47
       47
       -
             description = ''

     

       48
       48
       -
               The virtual console (tty) that greetd should use. This option also disables getty on that tty.

     

       49
       49
       -
             '';

     

       50
       50
       -
           };

     

       51
       51
       -
       

     

       52
       52
        
           restart = lib.mkOption {

     

       53
       53
        
             type = lib.types.bool;

     

       54
       54
        
             default = !(cfg.settings ? initial_session);

     
···

       62
       62
        
         };

     

       63
       63
        
         config = lib.mkIf cfg.enable {

     

       64
       64
        
       

     

       65
       65
       -
           services.greetd.settings.terminal.vt = lib.mkDefault cfg.vt;

     

       65
       65
       +
           services.greetd.settings.terminal.vt = 1;

     

       66
       66
        
           services.greetd.settings.default_session.user = lib.mkDefault "greeter";

     

       67
       67
        
       

     

       68
       68
        
           security.pam.services.greetd = {

+14 -14

nixos/modules/services/display-managers/lemurs.nix

···

       9
       9
        
         settingsFormat = pkgs.formats.toml { };

     

       10
       10
        
       in

     

       11
       11
        
       {

     

       12
       12
       +
         imports = [

     

       13
       13
       +
           (lib.mkRemovedOptionModule [

     

       14
       14
       +
             "services"

     

       15
       15
       +
             "displayManager"

     

       16
       16
       +
             "lemurs"

     

       17
       17
       +
             "vt"

     

       18
       18
       +
           ] "The VT is now fixed to VT1.")

     

       19
       19
       +
         ];

     

       20
       20
       +
       

     

       12
       21
        
         options.services.displayManager.lemurs = {

     

       13
       22
        
           enable = lib.mkEnableOption "" // {

     

       14
       23
        
             description = ''

     
···

       36
       45
        
               See [lemurs configuration documentation](https://github.com/coastalwhite/lemurs/blob/main/extra/config.toml) for available options.

     

       37
       46
        
             '';

     

       38
       47
        
           };

     

       39
       39
       -
       

     

       40
       40
       -
           vt = lib.mkOption {

     

       41
       41
       -
             type = lib.types.ints.positive;

     

       42
       42
       -
             default = 2;

     

       43
       43
       -
             description = ''

     

       44
       44
       -
               The virtual console (tty) that lemurs should use.

     

       45
       45
       -
             '';

     

       46
       46
       -
           };

     

       47
       48
        
         };

     

       48
       49
        
         config = lib.mkIf cfg.enable {

     

       49
       50
        
           assertions = [

     
···

       70
       71
        
             # Required for wayland with setLoginUid = false;

     

       71
       72
        
             seatd.enable = true;

     

       72
       73
        
             xserver = {

     

       73
       73
       -
               # To enable user switching, allow lemurs to allocate TTYs/displays dynamically.

     

       74
       74
       -
               tty = null;

     

       74
       74
       +
               # To enable user switching, allow lemurs to allocate displays dynamically.

     

       75
       75
        
               display = null;

     

       76
       76
        
             };

     

       77
       77
        
             displayManager = {

     
···

       83
       83
        
                   desktops = config.services.displayManager.sessionData.desktops;

     

       84
       84
        
                 in

     

       85
       85
        
                 {

     

       86
       86
       -
                   tty = lib.mkDefault cfg.vt;

     

       86
       86
       +
                   tty = 1;

     

       87
       87
        
                   system_shell = lib.mkDefault "${pkgs.bash}/bin/bash";

     

       88
       88
        
                   initial_path = lib.mkDefault "/run/current-system/sw/bin";

     

       89
       89
        
                   x11 = {

     
···

       102
       102
        
               Wants = [ "systemd-user-sessions.service" ];

     

       103
       103
        
               After = [

     

       104
       104
        
                 "systemd-user-sessions.service"

     

       105
       105
       -
                 "getty@tty${toString cfg.vt}.service"

     

       106
       105
        
                 "plymouth-quit-wait.service"

     

       107
       106
        
               ];

     

       108
       108
       -
               Conflicts = [ "getty@tty${toString cfg.vt}.service" ];

     

       109
       107
        
             };

     

       110
       108
        
             serviceConfig = {

     

       111
       109
        
               Type = "idle";

     

       112
       110
        
               # Defaults from lemurs upstream configuration

     

       113
       111
        
               StandardInput = "tty";

     

       114
       114
       -
               TTYPath = "/dev/tty${toString cfg.vt}";

     

       112
       112
       +
               TTYPath = "/dev/tty1";

     

       115
       113
        
               TTYReset = "yes";

     

       116
       114
        
               TTYVHangup = "yes";

     

       115
       115
       +
               # Clear the console before starting

     

       116
       116
       +
               TTYVTDisallocate = true;

     

       117
       117
        
             };

     

       118
       118
        
             # Don't kill a user session when using nixos-rebuild

     

       119
       119
        
             restartIfChanged = false;

+5 -6

nixos/modules/services/display-managers/ly.nix

···

       36
       36
        
         defaultConfig = {

     

       37
       37
        
           shutdown_cmd = "/run/current-system/systemd/bin/systemctl poweroff";

     

       38
       38
        
           restart_cmd = "/run/current-system/systemd/bin/systemctl reboot";

     

       39
       39
       -
           tty = 2;

     

       40
       39
        
           service_name = "ly";

     

       41
       40
        
           path = "/run/current-system/sw/bin";

     

       42
       41
        
           term_reset_cmd = "${pkgs.ncurses}/bin/tput reset";

     
···

       115
       114
        
             displayManager = {

     

       116
       115
        
               enable = true;

     

       117
       116
        
               execCmd = "exec /run/current-system/sw/bin/ly";

     

       117
       117
       +
       

     

       118
       118
       +
               # Set this here instead of 'defaultConfig' so users get eval

     

       119
       119
       +
               # errors when they change it.

     

       120
       120
       +
               ly.settings.tty = 1;

     

       118
       121
        
             };

     

       119
       122
        
       

     

       120
       123
        
             xserver = {

     

       121
       121
       -
               # To enable user switching, allow ly to allocate TTYs/displays dynamically.

     

       122
       122
       -
               tty = null;

     

       124
       124
       +
               # To enable user switching, allow ly to allocate displays dynamically.

     

       123
       125
        
               display = null;

     

       124
       126
        
             };

     

       125
       127
        
           };

     
···

       131
       133
        
               after = [

     

       132
       134
        
                 "systemd-user-sessions.service"

     

       133
       135
        
                 "plymouth-quit-wait.service"

     

       134
       134
       -
                 "getty@tty${toString finalConfig.tty}.service"

     

       135
       136
        
               ];

     

       136
       136
       -
       

     

       137
       137
       -
               conflicts = [ "getty@tty7.service" ];

     

       138
       137
        
       

     

       139
       138
        
               serviceConfig = {

     

       140
       139
        
                 Type = "idle";

+1 -7

nixos/modules/services/display-managers/sddm.nix

···

       93
       93
        
         }

     

       94
       94
        
         // optionalAttrs xcfg.enable {

     

       95
       95
        
           X11 = {

     

       96
       96
       -
             MinimumVT = if xcfg.tty != null then xcfg.tty else 7;

     

       97
       96
        
             ServerPath = toString xserverWrapper;

     

       98
       97
        
             XephyrPath = "${pkgs.xorg.xorgserver.out}/bin/Xephyr";

     

       99
       98
        
             SessionCommand = toString dmcfg.sessionData.wrapper;

     
···

       419
       418
        
           services = {

     

       420
       419
        
             dbus.packages = [ sddm ];

     

       421
       420
        
             xserver = {

     

       422
       422
       -
               # To enable user switching, allow sddm to allocate TTYs/displays dynamically.

     

       423
       423
       -
               tty = null;

     

       421
       421
       +
               # To enable user switching, allow sddm to allocate displays dynamically.

     

       424
       422
        
               display = null;

     

       425
       423
        
             };

     

       426
       424
        
           };

     
···

       432
       430
        
             services.display-manager = {

     

       433
       431
        
               after = [

     

       434
       432
        
                 "systemd-user-sessions.service"

     

       435
       435
       -
                 "getty@tty7.service"

     

       436
       433
        
                 "plymouth-quit.service"

     

       437
       434
        
                 "systemd-logind.service"

     

       438
       438
       -
               ];

     

       439
       439
       -
               conflicts = [

     

       440
       440
       -
                 "getty@tty7.service"

     

       441
       435
        
               ];

     

       442
       436
        
             };

     

       443
       437
        
           };

+2

nixos/modules/services/ttys/getty.nix

···

       148
       148
        
             "container-getty@.service"

     

       149
       149
        
           ];

     

       150
       150
        
       

     

       151
       151
       +
           systemd.targets.getty.wants = [ "autovt@tty1.service" ];

     

       152
       152
       +
       

     

       151
       153
        
           systemd.services."getty@" = {

     

       152
       154
        
             serviceConfig.ExecStart = [

     

       153
       155
        
               # override upstream default with an empty ExecStart

+1 -9

nixos/modules/services/x11/display-managers/lightdm.nix

···

       42
       42
        
       

     

       43
       43
        
         lightdmConf = writeText "lightdm.conf" ''

     

       44
       44
        
           [LightDM]

     

       45
       45
       +
           minimum-vt = 1

     

       45
       46
        
           ${optionalString cfg.greeter.enable ''

     

       46
       47
        
             greeter-user = ${config.users.users.lightdm.name}

     

       47
       48
        
             greeters-directory = ${cfg.greeter.package}

     
···

       234
       235
        
             exec ${lightdm}/sbin/lightdm

     

       235
       236
        
           '';

     

       236
       237
        
       

     

       237
       237
       -
           # Replaces getty

     

       238
       238
       -
           systemd.services.display-manager.conflicts = [

     

       239
       239
       -
             "getty@tty7.service"

     

       240
       240
       -
             # TODO: Add "plymouth-quit.service" so LightDM can control when plymouth

     

       241
       241
       -
             # quits. Currently this breaks switching to configurations with plymouth.

     

       242
       242
       -
           ];

     

       243
       243
       -
       

     

       244
       238
        
           # Pull in dependencies of services we replace.

     

       245
       239
        
           systemd.services.display-manager.after = [

     

       246
       240
        
             "rc-local.service"

     

       247
       241
        
             "systemd-machined.service"

     

       248
       242
        
             "systemd-user-sessions.service"

     

       249
       249
       -
             "getty@tty7.service"

     

       250
       243
        
             "user.slice"

     

       251
       244
        
           ];

     

       252
       245
        
       

     
···

       336
       329
        
           ];

     

       337
       330
        
       

     

       338
       331
        
           users.groups.lightdm.gid = config.ids.gids.lightdm;

     

       339
       339
       -
           services.xserver.tty = null; # We might start multiple X servers so let the tty increment themselves..

     

       340
       332
        
           services.xserver.display = null; # We specify our own display (and logfile) in xserver-wrapper up there

     

       341
       333
        
         };

     

       342
       334
        
       }

+5 -7

nixos/modules/services/x11/xserver.nix

···

       277
       277
        
               "dir"

     

       278
       278
        
             ];

     

       279
       279
        
           })

     

       280
       280
       +
           (lib.mkRemovedOptionModule [

     

       281
       281
       +
             "services"

     

       282
       282
       +
             "xserver"

     

       283
       283
       +
             "tty"

     

       284
       284
       +
           ] "'services.xserver.tty' was removed because it was ineffective.")

     

       280
       285
        
         ];

     

       281
       286
        
       

     

       282
       287
        
         ###### interface

     
···

       675
       680
        
               '';

     

       676
       681
        
             };

     

       677
       682
        
       

     

       678
       678
       -
             tty = mkOption {

     

       679
       679
       -
               type = types.nullOr types.int;

     

       680
       680
       -
               default = 7;

     

       681
       681
       -
               description = "Virtual console for the X server.";

     

       682
       682
       -
             };

     

       683
       683
       -
       

     

       684
       683
        
             display = mkOption {

     

       685
       684
        
               type = types.nullOr types.int;

     

       686
       685
        
               default = 0;

     
···

       886
       885
        
             "${cfg.xkb.dir}"

     

       887
       886
        
           ]

     

       888
       887
        
           ++ optional (cfg.display != null) ":${toString cfg.display}"

     

       889
       889
       -
           ++ optional (cfg.tty != null) "vt${toString cfg.tty}"

     

       890
       888
        
           ++ optional (cfg.dpi != null) "-dpi ${toString cfg.dpi}"

     

       891
       889
        
           ++ optional (cfg.logFile != null) "-logfile ${toString cfg.logFile}"

     

       892
       890
        
           ++ optional (cfg.verbose != null) "-verbose ${toString cfg.verbose}"

+3 -1

nixos/tests/lemurs/lemurs.nix

···

       11
       11
        
           ];

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
       +
         enableOCR = true;

     

       15
       15
       +
       

     

       14
       16
        
         nodes.machine = _: {

     

       15
       17
        
           imports = [ ../common/user-account.nix ];

     

       16
       18
        
           services.displayManager.lemurs.enable = true;

     
···

       20
       22
        
           machine.start()

     

       21
       23
        
       

     

       22
       24
        
           machine.wait_for_unit("multi-user.target")

     

       23
       23
       -
           machine.wait_until_succeeds("pgrep -f 'lemurs.*tty1'")

     

       25
       25
       +
           machine.wait_for_text("Login")

     

       24
       26
        
           machine.screenshot("postboot")

     

       25
       27
        
       

     

       26
       28
        
           with subtest("Log in as alice on a virtual console"):

+1 -3

pkgs/applications/display-managers/sddm/unwrapped.nix

···

       72
       72
        
           "-DUID_MIN=1000"

     

       73
       73
        
           "-DUID_MAX=29999"

     

       74
       74
        
       

     

       75
       75
       -
           # we still want to run the DM on VT 7 for the time being, as 1-6 are

     

       76
       76
       -
           # occupied by getties by default

     

       77
       77
       -
           "-DSDDM_INITIAL_VT=7"

     

       75
       75
       +
           "-DSDDM_INITIAL_VT=1"

     

       78
       76
        
       

     

       79
       77
        
           "-DQT_IMPORTS_DIR=${placeholder "out"}/${qtbase.qtQmlPrefix}"

     

       80
       78
        
           "-DCMAKE_INSTALL_SYSCONFDIR=${placeholder "out"}/etc"

+2 -2

pkgs/applications/networking/mailreaders/thunderbird/packages.nix

···

       94
       94
        
         thunderbird = thunderbird-latest;

     

       95
       95
        
       

     

       96
       96
        
         thunderbird-latest = common {

     

       97
       97
       -
           version = "140.0.1";

     

       98
       98
       -
           sha512 = "fbef1d0228c49fc9c11425b6be03bb7e44e6abc6f2027ee23317270ca2c6b0a935bb41b38667acf014bd9e1166cbe62754f1e919e04f2355dc4c833e015c78b8";

     

       97
       97
       +
           version = "141.0";

     

       98
       98
       +
           sha512 = "cd747c0831532f90685975567102d1bdb90a780e21209fe4b7bddf2d84ac88576766706e95e22043a30a8a89b6d3daffb56a68c3ccc4a300b8236b20d4fca675";

     

       99
       99
        
       

     

       100
       100
        
           updateScript = callPackage ./update.nix {

     

       101
       101
        
             attrPath = "thunderbirdPackages.thunderbird-latest";

+1 -4

pkgs/by-name/gd/gdm/package.nix

···

       59
       59
        
         mesonFlags = [

     

       60
       60
        
           "-Dgdm-xsession=true"

     

       61
       61
        
           # TODO: Setup a default-path? https://gitlab.gnome.org/GNOME/gdm/-/blob/6fc40ac6aa37c8ad87c32f0b1a5d813d34bf7770/meson_options.txt#L6

     

       62
       62
       -
           "-Dinitial-vt=${finalAttrs.passthru.initialVT}"

     

       62
       62
       +
           "-Dinitial-vt=1"

     

       63
       63
        
           "-Dudev-dir=${placeholder "out"}/lib/udev/rules.d"

     

       64
       64
        
           "-Dsystemdsystemunitdir=${placeholder "out"}/lib/systemd/system"

     

       65
       65
        
           "-Dsystemduserunitdir=${placeholder "out"}/lib/systemd/user"

     
···

       185
       185
        
         passthru = {

     

       186
       186
        
           updateScript = gnome.updateScript { packageName = "gdm"; };

     

       187
       187
        
       

     

       188
       188
       -
           # Used in GDM NixOS module

     

       189
       189
       -
           # Don't remove.

     

       190
       190
       -
           initialVT = "7";

     

       191
       188
        
           dconfDb = "${finalAttrs.finalPackage}/share/gdm/greeter-dconf-defaults";

     

       192
       189
        
           dconfProfile = "user-db:user\nfile-db:${finalAttrs.passthru.dconfDb}";

     

       193
       190

+2 -2

pkgs/by-name/ma/makejinja/package.nix

···

       6
       6
        
       

     

       7
       7
        
       python3Packages.buildPythonApplication rec {

     

       8
       8
        
         pname = "makejinja";

     

       9
       9
       -
         version = "2.8.0";

     

       9
       9
       +
         version = "2.8.1";

     

       10
       10
        
         pyproject = true;

     

       11
       11
        
       

     

       12
       12
        
         src = fetchFromGitHub {

     

       13
       13
        
           owner = "mirkolenz";

     

       14
       14
        
           repo = "makejinja";

     

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

     

       16
       16
       -
           hash = "sha256-Y6R+nVwIuviYhvLp5Aqb+BUCaAD6fF+GH8zmJrWNxFc=";

     

       16
       16
       +
           hash = "sha256-vK5MJb4n3/NmkohpJ1shEexvjHlEAfwZJWy2oL+rzRk=";

     

       17
       17
        
         };

     

       18
       18
        
       

     

       19
       19
        
         build-system = with python3Packages; [ setuptools ];

+2 -2

pkgs/development/libraries/ngtcp2/gnutls.nix

···

       12
       12
        
       

     

       13
       13
        
       stdenv.mkDerivation rec {

     

       14
       14
        
         pname = "ngtcp2";

     

       15
       15
       -
         version = "1.13.0";

     

       15
       15
       +
         version = "1.14.0";

     

       16
       16
        
       

     

       17
       17
        
         src = fetchFromGitHub {

     

       18
       18
        
           owner = "ngtcp2";

     

       19
       19
        
           repo = "ngtcp2";

     

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

     

       21
       21
       -
           hash = "sha256-SvxGZoV4N9wNAsI5pOjjGECgk2vV0FifzHi1gbGjqnc=";

     

       21
       21
       +
           hash = "sha256-TpfCfVhguFbTqQiY+zl6Kn7fsIQHR1tvNC4YLkxmBis=";

     

       22
       22
        
         };

     

       23
       23
        
       

     

       24
       24
        
         outputs = [

+2 -2

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

···

       51
       51
        
       

     

       52
       52
        
       buildPythonPackage rec {

     

       53
       53
        
         pname = "openai";

     

       54
       54
       -
         version = "1.97.0";

     

       54
       54
       +
         version = "1.97.1";

     

       55
       55
        
         pyproject = true;

     

       56
       56
        
       

     

       57
       57
        
         src = fetchFromGitHub {

     

       58
       58
        
           owner = "openai";

     

       59
       59
        
           repo = "openai-python";

     

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

     

       61
       61
       -
           hash = "sha256-q+GUEHducm71Zqh7ZfRF217awFKQIsOSEWoe04M3DFM=";

     

       61
       61
       +
           hash = "sha256-ANY74P3tM8VVPh9m6hOdZSkMhcQphi72bKNcLrsLEq8=";

     

       62
       62
        
         };

     

       63
       63
        
       

     

       64
       64
        
         postPatch = ''substituteInPlace pyproject.toml --replace-fail "hatchling==1.26.3" "hatchling"'';