commit 6c1dce19737afa171d64ed40c6fc8bde71d27f58 · pyrox.dev/nixpkgs

+5

.github/labeler.yml

···

       37
       37
        
       "6.topic: fetch":

     

       38
       38
        
         - pkgs/build-support/fetch*/**/*

     

       39
       39
        
       

     

       40
       40
       +
       "6.topic: flakes":

     

       41
       41
       +
         - '**/flake.nix'

     

       42
       42
       +
         - lib/systems/flake-systems.nix

     

       43
       43
       +
         - nixos/modules/config/nix-flakes.nix

     

       44
       44
       +
       

     

       40
       45
        
       "6.topic: GNOME":

     

       41
       46
        
         - doc/languages-frameworks/gnome.section.md

     

       42
       47
        
         - nixos/modules/services/desktops/gnome/**/*

+113

lib/fileset/default.nix

···

       12
       12
        
           _printFileset

     

       13
       13
        
           _intersection

     

       14
       14
        
           _difference

     

       15
       15
       +
           _mirrorStorePath

     

       16
       16
       +
           _fetchGitSubmodulesMinver

     

       15
       17
        
           ;

     

       16
       18
        
       

     

       17
       19
        
         inherit (builtins)

     

       20
       20
       +
           isBool

     

       18
       21
        
           isList

     

       19
       22
        
           isPath

     

       20
       23
        
           pathExists

     

       21
       24
        
           seq

     

       22
       25
        
           typeOf

     

       26
       26
       +
           nixVersion

     

       23
       27
        
           ;

     

       24
       28
        
       

     

       25
       29
        
         inherit (lib.lists)

     
···

       34
       38
        
       

     

       35
       39
        
         inherit (lib.strings)

     

       36
       40
        
           isStringLike

     

       41
       41
       +
           versionOlder

     

       37
       42
        
           ;

     

       38
       43
        
       

     

       39
       44
        
         inherit (lib.filesystem)

     
···

       47
       52
        
         inherit (lib.trivial)

     

       48
       53
        
           isFunction

     

       49
       54
        
           pipe

     

       55
       55
       +
           inPureEvalMode

     

       50
       56
        
           ;

     

       51
       57
        
       

     

       52
       58
        
       in {

     
···

       596
       602
        
             # We could also return the original fileset argument here,

     

       597
       603
        
             # but that would then duplicate work for consumers of the fileset, because then they have to coerce it again

     

       598
       604
        
             actualFileset;

     

       605
       605
       +
       

     

       606
       606
       +
         /*

     

       607
       607
       +
           Create a file set containing all [Git-tracked files](https://git-scm.com/book/en/v2/Git-Basics-Recording-Changes-to-the-Repository) in a repository.

     

       608
       608
       +
       

     

       609
       609
       +
           This function behaves like [`gitTrackedWith { }`](#function-library-lib.fileset.gitTrackedWith) - using the defaults.

     

       610
       610
       +
       

     

       611
       611
       +
           Type:

     

       612
       612
       +
             gitTracked :: Path -> FileSet

     

       613
       613
       +
       

     

       614
       614
       +
           Example:

     

       615
       615
       +
             # Include all files tracked by the Git repository in the current directory

     

       616
       616
       +
             gitTracked ./.

     

       617
       617
       +
       

     

       618
       618
       +
             # Include only files tracked by the Git repository in the parent directory

     

       619
       619
       +
             # that are also in the current directory

     

       620
       620
       +
             intersection ./. (gitTracked ../.)

     

       621
       621
       +
         */

     

       622
       622
       +
         gitTracked =

     

       623
       623
       +
           /*

     

       624
       624
       +
             The [path](https://nixos.org/manual/nix/stable/language/values#type-path) to the working directory of a local Git repository.

     

       625
       625
       +
             This directory must contain a `.git` file or subdirectory.

     

       626
       626
       +
           */

     

       627
       627
       +
           path:

     

       628
       628
       +
           # See the gitTrackedWith implementation for more explanatory comments

     

       629
       629
       +
           let

     

       630
       630
       +
             fetchResult = builtins.fetchGit path;

     

       631
       631
       +
           in

     

       632
       632
       +
           if inPureEvalMode then

     

       633
       633
       +
             throw "lib.fileset.gitTracked: This function is currently not supported in pure evaluation mode, since it currently relies on `builtins.fetchGit`. See https://github.com/NixOS/nix/issues/9292."

     

       634
       634
       +
           else if ! isPath path then

     

       635
       635
       +
             throw "lib.fileset.gitTracked: Expected the argument to be a path, but it's a ${typeOf path} instead."

     

       636
       636
       +
           else if ! pathExists (path + "/.git") then

     

       637
       637
       +
             throw "lib.fileset.gitTracked: Expected the argument (${toString path}) to point to a local working tree of a Git repository, but it's not."

     

       638
       638
       +
           else

     

       639
       639
       +
             _mirrorStorePath path fetchResult.outPath;

     

       640
       640
       +
       

     

       641
       641
       +
         /*

     

       642
       642
       +
           Create a file set containing all [Git-tracked files](https://git-scm.com/book/en/v2/Git-Basics-Recording-Changes-to-the-Repository) in a repository.

     

       643
       643
       +
           The first argument allows configuration with an attribute set,

     

       644
       644
       +
           while the second argument is the path to the Git working tree.

     

       645
       645
       +
           If you don't need the configuration,

     

       646
       646
       +
           you can use [`gitTracked`](#function-library-lib.fileset.gitTracked) instead.

     

       647
       647
       +
       

     

       648
       648
       +
           This is equivalent to the result of [`unions`](#function-library-lib.fileset.unions) on all files returned by [`git ls-files`](https://git-scm.com/docs/git-ls-files)

     

       649
       649
       +
           (which uses [`--cached`](https://git-scm.com/docs/git-ls-files#Documentation/git-ls-files.txt--c) by default).

     

       650
       650
       +
       

     

       651
       651
       +
           :::{.warning}

     

       652
       652
       +
           Currently this function is based on [`builtins.fetchGit`](https://nixos.org/manual/nix/stable/language/builtins.html#builtins-fetchGit)

     

       653
       653
       +
           As such, this function causes all Git-tracked files to be unnecessarily added to the Nix store,

     

       654
       654
       +
           without being re-usable by [`toSource`](#function-library-lib.fileset.toSource).

     

       655
       655
       +
       

     

       656
       656
       +
           This may change in the future.

     

       657
       657
       +
           :::

     

       658
       658
       +
       

     

       659
       659
       +
           Type:

     

       660
       660
       +
             gitTrackedWith :: { recurseSubmodules :: Bool ? false } -> Path -> FileSet

     

       661
       661
       +
       

     

       662
       662
       +
           Example:

     

       663
       663
       +
             # Include all files tracked by the Git repository in the current directory

     

       664
       664
       +
             # and any submodules under it

     

       665
       665
       +
             gitTracked { recurseSubmodules = true; } ./.

     

       666
       666
       +
         */

     

       667
       667
       +
         gitTrackedWith =

     

       668
       668
       +
           {

     

       669
       669
       +
             /*

     

       670
       670
       +
               (optional, default: `false`) Whether to recurse into [Git submodules](https://git-scm.com/book/en/v2/Git-Tools-Submodules) to also include their tracked files.

     

       671
       671
       +
       

     

       672
       672
       +
               If `true`, this is equivalent to passing the [--recurse-submodules](https://git-scm.com/docs/git-ls-files#Documentation/git-ls-files.txt---recurse-submodules) flag to `git ls-files`.

     

       673
       673
       +
             */

     

       674
       674
       +
             recurseSubmodules ? false,

     

       675
       675
       +
           }:

     

       676
       676
       +
           /*

     

       677
       677
       +
             The [path](https://nixos.org/manual/nix/stable/language/values#type-path) to the working directory of a local Git repository.

     

       678
       678
       +
             This directory must contain a `.git` file or subdirectory.

     

       679
       679
       +
           */

     

       680
       680
       +
           path:

     

       681
       681
       +
           let

     

       682
       682
       +
             # This imports the files unnecessarily, which currently can't be avoided

     

       683
       683
       +
             # because `builtins.fetchGit` is the only function exposing which files are tracked by Git.

     

       684
       684
       +
             # With the [lazy trees PR](https://github.com/NixOS/nix/pull/6530),

     

       685
       685
       +
             # the unnecessarily import could be avoided.

     

       686
       686
       +
             # However a simpler alternative still would be [a builtins.gitLsFiles](https://github.com/NixOS/nix/issues/2944).

     

       687
       687
       +
             fetchResult = builtins.fetchGit {

     

       688
       688
       +
               url = path;

     

       689
       689
       +
       

     

       690
       690
       +
               # This is the only `fetchGit` parameter that makes sense in this context.

     

       691
       691
       +
               # We can't just pass `submodules = recurseSubmodules` here because

     

       692
       692
       +
               # this would fail for Nix versions that don't support `submodules`.

     

       693
       693
       +
               ${if recurseSubmodules then "submodules" else null} = true;

     

       694
       694
       +
             };

     

       695
       695
       +
           in

     

       696
       696
       +
           if inPureEvalMode then

     

       697
       697
       +
             throw "lib.fileset.gitTrackedWith: This function is currently not supported in pure evaluation mode, since it currently relies on `builtins.fetchGit`. See https://github.com/NixOS/nix/issues/9292."

     

       698
       698
       +
           else if ! isBool recurseSubmodules then

     

       699
       699
       +
             throw "lib.fileset.gitTrackedWith: Expected the attribute `recurseSubmodules` of the first argument to be a boolean, but it's a ${typeOf recurseSubmodules} instead."

     

       700
       700
       +
           else if recurseSubmodules && versionOlder nixVersion _fetchGitSubmodulesMinver then

     

       701
       701
       +
             throw "lib.fileset.gitTrackedWith: Setting the attribute `recurseSubmodules` to `true` is only supported for Nix version ${_fetchGitSubmodulesMinver} and after, but Nix version ${nixVersion} is used."

     

       702
       702
       +
           else if ! isPath path then

     

       703
       703
       +
             throw "lib.fileset.gitTrackedWith: Expected the second argument to be a path, but it's a ${typeOf path} instead."

     

       704
       704
       +
           # We can identify local working directories by checking for .git,

     

       705
       705
       +
           # see https://git-scm.com/docs/gitrepository-layout#_description.

     

       706
       706
       +
           # Note that `builtins.fetchGit` _does_ work for bare repositories (where there's no `.git`),

     

       707
       707
       +
           # even though `git ls-files` wouldn't return any files in that case.

     

       708
       708
       +
           else if ! pathExists (path + "/.git") then

     

       709
       709
       +
             throw "lib.fileset.gitTrackedWith: Expected the second argument (${toString path}) to point to a local working tree of a Git repository, but it's not."

     

       710
       710
       +
           else

     

       711
       711
       +
             _mirrorStorePath path fetchResult.outPath;

     

       599
       712
        
       }

+23

lib/fileset/internal.nix

···

       825
       825
        
               ${baseNameOf root} =

     

       826
       826
        
                 fromFile (baseNameOf root) rootType;

     

       827
       827
        
             };

     

       828
       828
       +
       

     

       829
       829
       +
         # Support for `builtins.fetchGit` with `submodules = true` was introduced in 2.4

     

       830
       830
       +
         # https://github.com/NixOS/nix/commit/55cefd41d63368d4286568e2956afd535cb44018

     

       831
       831
       +
         _fetchGitSubmodulesMinver = "2.4";

     

       832
       832
       +
       

     

       833
       833
       +
         # Mirrors the contents of a Nix store path relative to a local path as a file set.

     

       834
       834
       +
         # Some notes:

     

       835
       835
       +
         # - The store path is read at evaluation time.

     

       836
       836
       +
         # - The store path must not include files that don't exist in the respective local path.

     

       837
       837
       +
         #

     

       838
       838
       +
         # Type: Path -> String -> FileSet

     

       839
       839
       +
         _mirrorStorePath = localPath: storePath:

     

       840
       840
       +
           let

     

       841
       841
       +
             recurse = focusedStorePath:

     

       842
       842
       +
               mapAttrs (name: type:

     

       843
       843
       +
                 if type == "directory" then

     

       844
       844
       +
                   recurse (focusedStorePath + "/${name}")

     

       845
       845
       +
                 else

     

       846
       846
       +
                   type

     

       847
       847
       +
               ) (builtins.readDir focusedStorePath);

     

       848
       848
       +
           in

     

       849
       849
       +
           _create localPath

     

       850
       850
       +
             (recurse storePath);

     

       828
       851
        
       }

+210 -16

lib/fileset/tests.sh

···

       43
       43
        
           cut -d \" -f2

     

       44
       44
        
       }

     

       45
       45
        
       

     

       46
       46
       -
       prefixExpression='let

     

       47
       47
       -
         lib = import <nixpkgs/lib>;

     

       48
       48
       -
         internal = import <nixpkgs/lib/fileset/internal.nix> {

     

       49
       49
       -
           inherit lib;

     

       50
       50
       -
         };

     

       51
       51
       -
       in

     

       52
       52
       -
       with lib;

     

       53
       53
       -
       with internal;

     

       54
       54
       -
       with lib.fileset;'

     

       46
       46
       +
       prefixExpression() {

     

       47
       47
       +
           echo 'let

     

       48
       48
       +
             lib =

     

       49
       49
       +
               (import <nixpkgs/lib>)

     

       50
       50
       +
           '

     

       51
       51
       +
           if [[ "${1:-}" == "--simulate-pure-eval" ]]; then

     

       52
       52
       +
               echo '

     

       53
       53
       +
               .extend (final: prev: {

     

       54
       54
       +
                 trivial = prev.trivial // {

     

       55
       55
       +
                   inPureEvalMode = true;

     

       56
       56
       +
                 };

     

       57
       57
       +
               })'

     

       58
       58
       +
           fi

     

       59
       59
       +
           echo '

     

       60
       60
       +
             ;

     

       61
       61
       +
             internal = import <nixpkgs/lib/fileset/internal.nix> {

     

       62
       62
       +
               inherit lib;

     

       63
       63
       +
             };

     

       64
       64
       +
           in

     

       65
       65
       +
           with lib;

     

       66
       66
       +
           with internal;

     

       67
       67
       +
           with lib.fileset;'

     

       68
       68
       +
       }

     

       55
       69
        
       

     

       56
       70
        
       # Check that two nix expression successfully evaluate to the same value.

     

       57
       71
        
       # The expressions have `lib.fileset` in scope.

     
···

       60
       74
        
           local actualExpr=$1

     

       61
       75
        
           local expectedExpr=$2

     

       62
       76
        
           if actualResult=$(nix-instantiate --eval --strict --show-trace 2>"$tmp"/actualStderr \

     

       63
       63
       -
               --expr "$prefixExpression ($actualExpr)"); then

     

       77
       77
       +
               --expr "$(prefixExpression) ($actualExpr)"); then

     

       64
       78
        
               actualExitCode=$?

     

       65
       79
        
           else

     

       66
       80
        
               actualExitCode=$?

     
···

       68
       82
        
           actualStderr=$(< "$tmp"/actualStderr)

     

       69
       83
        
       

     

       70
       84
        
           if expectedResult=$(nix-instantiate --eval --strict --show-trace 2>"$tmp"/expectedStderr \

     

       71
       71
       -
               --expr "$prefixExpression ($expectedExpr)"); then

     

       85
       85
       +
               --expr "$(prefixExpression) ($expectedExpr)"); then

     

       72
       86
        
               expectedExitCode=$?

     

       73
       87
        
           else

     

       74
       88
        
               expectedExitCode=$?

     
···

       95
       109
        
       # Usage: expectStorePath NIX

     

       96
       110
        
       expectStorePath() {

     

       97
       111
        
           local expr=$1

     

       98
       98
       -
           if ! result=$(nix-instantiate --eval --strict --json --read-write-mode --show-trace \

     

       99
       99
       -
               --expr "$prefixExpression ($expr)"); then

     

       112
       112
       +
           if ! result=$(nix-instantiate --eval --strict --json --read-write-mode --show-trace 2>"$tmp"/stderr \

     

       113
       113
       +
               --expr "$(prefixExpression) ($expr)"); then

     

       114
       114
       +
               cat "$tmp/stderr" >&2

     

       100
       115
        
               die "$expr failed to evaluate, but it was expected to succeed"

     

       101
       116
        
           fi

     

       102
       117
        
           # This is safe because we assume to get back a store path in a string

     
···

       108
       123
        
       # The expression has `lib.fileset` in scope.

     

       109
       124
        
       # Usage: expectFailure NIX REGEX

     

       110
       125
        
       expectFailure() {

     

       126
       126
       +
           if [[ "$1" == "--simulate-pure-eval" ]]; then

     

       127
       127
       +
               maybePure="--simulate-pure-eval"

     

       128
       128
       +
               shift

     

       129
       129
       +
           else

     

       130
       130
       +
               maybePure=""

     

       131
       131
       +
           fi

     

       111
       132
        
           local expr=$1

     

       112
       133
        
           local expectedErrorRegex=$2

     

       113
       134
        
           if result=$(nix-instantiate --eval --strict --read-write-mode --show-trace 2>"$tmp/stderr" \

     

       114
       114
       -
               --expr "$prefixExpression $expr"); then

     

       135
       135
       +
               --expr "$(prefixExpression $maybePure) $expr"); then

     

       115
       136
        
               die "$expr evaluated successfully to $result, but it was expected to fail"

     

       116
       137
        
           fi

     

       117
       138
        
           stderr=$(<"$tmp/stderr")

     
···

       128
       149
        
           local expectedTrace=$2

     

       129
       150
        
       

     

       130
       151
        
           nix-instantiate --eval --show-trace >/dev/null 2>"$tmp"/stderrTrace \

     

       131
       131
       -
               --expr "$prefixExpression trace ($expr)" || true

     

       152
       152
       +
               --expr "$(prefixExpression) trace ($expr)" || true

     

       132
       153
        
       

     

       133
       154
        
           actualTrace=$(sed -n 's/^trace: //p' "$tmp/stderrTrace")

     

       134
       155
        
       

     

       135
       156
        
           nix-instantiate --eval --show-trace >/dev/null 2>"$tmp"/stderrTraceVal \

     

       136
       136
       -
               --expr "$prefixExpression traceVal ($expr)" || true

     

       157
       157
       +
               --expr "$(prefixExpression) traceVal ($expr)" || true

     

       137
       158
        
       

     

       138
       159
        
           actualTraceVal=$(sed -n 's/^trace: //p' "$tmp/stderrTraceVal")

     

       139
       160
        
       

     
···

       1249
       1270
        
           else

     

       1250
       1271
        
             abort "filter should not be called on ${pathString}";

     

       1251
       1272
        
       }))) null' 'trace ./a/b null'

     

       1273
       1273
       +
       rm -rf -- *

     

       1274
       1274
       +
       

     

       1275
       1275
       +
       ## lib.fileset.gitTracked/gitTrackedWith

     

       1276
       1276
       +
       

     

       1277
       1277
       +
       # The first/second argument has to be a path

     

       1278
       1278
       +
       expectFailure 'gitTracked null' 'lib.fileset.gitTracked: Expected the argument to be a path, but it'\''s a null instead.'

     

       1279
       1279
       +
       expectFailure 'gitTrackedWith {} null' 'lib.fileset.gitTrackedWith: Expected the second argument to be a path, but it'\''s a null instead.'

     

       1280
       1280
       +
       

     

       1281
       1281
       +
       # The path has to contain a .git directory

     

       1282
       1282
       +
       expectFailure 'gitTracked ./.' 'lib.fileset.gitTracked: Expected the argument \('"$work"'\) to point to a local working tree of a Git repository, but it'\''s not.'

     

       1283
       1283
       +
       expectFailure 'gitTrackedWith {} ./.' 'lib.fileset.gitTrackedWith: Expected the second argument \('"$work"'\) to point to a local working tree of a Git repository, but it'\''s not.'

     

       1284
       1284
       +
       

     

       1285
       1285
       +
       # recurseSubmodules has to be a boolean

     

       1286
       1286
       +
       expectFailure 'gitTrackedWith { recurseSubmodules = null; } ./.' 'lib.fileset.gitTrackedWith: Expected the attribute `recurseSubmodules` of the first argument to be a boolean, but it'\''s a null instead.'

     

       1287
       1287
       +
       

     

       1288
       1288
       +
       # recurseSubmodules = true is not supported on all Nix versions

     

       1289
       1289
       +
       if [[ "$(nix-instantiate --eval --expr "$(prefixExpression) (versionAtLeast builtins.nixVersion _fetchGitSubmodulesMinver)")" == true ]]; then

     

       1290
       1290
       +
           fetchGitSupportsSubmodules=1

     

       1291
       1291
       +
       else

     

       1292
       1292
       +
           fetchGitSupportsSubmodules=

     

       1293
       1293
       +
           expectFailure 'gitTrackedWith { recurseSubmodules = true; } ./.' 'lib.fileset.gitTrackedWith: Setting the attribute `recurseSubmodules` to `true` is only supported for Nix version 2.4 and after, but Nix version [0-9.]+ is used.'

     

       1294
       1294
       +
       fi

     

       1295
       1295
       +
       

     

       1296
       1296
       +
       # Checks that `gitTrackedWith` contains the same files as `git ls-files`

     

       1297
       1297
       +
       # for the current working directory.

     

       1298
       1298
       +
       # If --recurse-submodules is passed, the flag is passed through to `git ls-files`

     

       1299
       1299
       +
       # and as `recurseSubmodules` to `gitTrackedWith`

     

       1300
       1300
       +
       checkGitTrackedWith() {

     

       1301
       1301
       +
           if [[ "${1:-}" == "--recurse-submodules" ]]; then

     

       1302
       1302
       +
               gitLsFlags="--recurse-submodules"

     

       1303
       1303
       +
               gitTrackedArg="{ recurseSubmodules = true; }"

     

       1304
       1304
       +
           else

     

       1305
       1305
       +
               gitLsFlags=""

     

       1306
       1306
       +
               gitTrackedArg="{ }"

     

       1307
       1307
       +
           fi

     

       1308
       1308
       +
       

     

       1309
       1309
       +
           # All files listed by `git ls-files`

     

       1310
       1310
       +
           expectedFiles=()

     

       1311
       1311
       +
           while IFS= read -r -d $'\0' file; do

     

       1312
       1312
       +
               # If there are submodules but --recurse-submodules isn't passed,

     

       1313
       1313
       +
               # `git ls-files` lists them as empty directories,

     

       1314
       1314
       +
               # we need to filter that out since we only want to check/count files

     

       1315
       1315
       +
               if [[ -f "$file" ]]; then

     

       1316
       1316
       +
                   expectedFiles+=("$file")

     

       1317
       1317
       +
               fi

     

       1318
       1318
       +
           done < <(git ls-files -z $gitLsFlags)

     

       1319
       1319
       +
       

     

       1320
       1320
       +
           storePath=$(expectStorePath 'toSource { root = ./.; fileset = gitTrackedWith '"$gitTrackedArg"' ./.; }')

     

       1321
       1321
       +
       

     

       1322
       1322
       +
           # Check that each expected file is also in the store path with the same content

     

       1323
       1323
       +
           for expectedFile in "${expectedFiles[@]}"; do

     

       1324
       1324
       +
               if [[ ! -e "$storePath"/"$expectedFile" ]]; then

     

       1325
       1325
       +
                   die "Expected file $expectedFile to exist in $storePath, but it doesn't.\nGit status:\n$(git status)\nStore path contents:\n$(find "$storePath")"

     

       1326
       1326
       +
               fi

     

       1327
       1327
       +
               if ! diff "$expectedFile" "$storePath"/"$expectedFile"; then

     

       1328
       1328
       +
                   die "Expected file $expectedFile to have the same contents as in $storePath, but it doesn't.\nGit status:\n$(git status)\nStore path contents:\n$(find "$storePath")"

     

       1329
       1329
       +
               fi

     

       1330
       1330
       +
           done

     

       1331
       1331
       +
       

     

       1332
       1332
       +
           # This is a cheap way to verify the inverse: That all files in the store path are also expected

     

       1333
       1333
       +
           # We just count the number of files in both and verify they're the same

     

       1334
       1334
       +
           actualFileCount=$(find "$storePath" -type f -printf . | wc -c)

     

       1335
       1335
       +
           if [[ "${#expectedFiles[@]}" != "$actualFileCount" ]]; then

     

       1336
       1336
       +
               die "Expected ${#expectedFiles[@]} files in $storePath, but got $actualFileCount.\nGit status:\n$(git status)\nStore path contents:\n$(find "$storePath")"

     

       1337
       1337
       +
           fi

     

       1338
       1338
       +
       }

     

       1339
       1339
       +
       

     

       1340
       1340
       +
       

     

       1341
       1341
       +
       # Runs checkGitTrackedWith with and without --recurse-submodules

     

       1342
       1342
       +
       # Allows testing both variants together

     

       1343
       1343
       +
       checkGitTracked() {

     

       1344
       1344
       +
           checkGitTrackedWith

     

       1345
       1345
       +
           if [[ -n "$fetchGitSupportsSubmodules" ]]; then

     

       1346
       1346
       +
               checkGitTrackedWith --recurse-submodules

     

       1347
       1347
       +
           fi

     

       1348
       1348
       +
       }

     

       1349
       1349
       +
       

     

       1350
       1350
       +
       createGitRepo() {

     

       1351
       1351
       +
           git init -q "$1"

     

       1352
       1352
       +
           # Only repo-local config

     

       1353
       1353
       +
           git -C "$1" config user.name "Nixpkgs"

     

       1354
       1354
       +
           git -C "$1" config user.email "nixpkgs@nixos.org"

     

       1355
       1355
       +
           # Get at least a HEAD commit, needed for older Nix versions

     

       1356
       1356
       +
           git -C "$1" commit -q --allow-empty -m "Empty commit"

     

       1357
       1357
       +
       }

     

       1358
       1358
       +
       

     

       1359
       1359
       +
       # Check the error message for pure eval mode

     

       1360
       1360
       +
       createGitRepo .

     

       1361
       1361
       +
       expectFailure --simulate-pure-eval 'toSource { root = ./.; fileset = gitTracked ./.; }' 'lib.fileset.gitTracked: This function is currently not supported in pure evaluation mode, since it currently relies on `builtins.fetchGit`. See https://github.com/NixOS/nix/issues/9292.'

     

       1362
       1362
       +
       expectFailure --simulate-pure-eval 'toSource { root = ./.; fileset = gitTrackedWith {} ./.; }' 'lib.fileset.gitTrackedWith: This function is currently not supported in pure evaluation mode, since it currently relies on `builtins.fetchGit`. See https://github.com/NixOS/nix/issues/9292.'

     

       1363
       1363
       +
       rm -rf -- *

     

       1364
       1364
       +
       

     

       1365
       1365
       +
       # Go through all stages of Git files

     

       1366
       1366
       +
       # See https://www.git-scm.com/book/en/v2/Git-Basics-Recording-Changes-to-the-Repository

     

       1367
       1367
       +
       

     

       1368
       1368
       +
       # Empty repository

     

       1369
       1369
       +
       createGitRepo .

     

       1370
       1370
       +
       checkGitTracked

     

       1371
       1371
       +
       

     

       1372
       1372
       +
       # Untracked file

     

       1373
       1373
       +
       echo a > a

     

       1374
       1374
       +
       checkGitTracked

     

       1375
       1375
       +
       

     

       1376
       1376
       +
       # Staged file

     

       1377
       1377
       +
       git add a

     

       1378
       1378
       +
       checkGitTracked

     

       1379
       1379
       +
       

     

       1380
       1380
       +
       # Committed file

     

       1381
       1381
       +
       git commit -q -m "Added a"

     

       1382
       1382
       +
       checkGitTracked

     

       1383
       1383
       +
       

     

       1384
       1384
       +
       # Edited file

     

       1385
       1385
       +
       echo b > a

     

       1386
       1386
       +
       checkGitTracked

     

       1387
       1387
       +
       

     

       1388
       1388
       +
       # Removed file

     

       1389
       1389
       +
       git rm -f -q a

     

       1390
       1390
       +
       checkGitTracked

     

       1391
       1391
       +
       

     

       1392
       1392
       +
       rm -rf -- *

     

       1393
       1393
       +
       

     

       1394
       1394
       +
       # gitignored file

     

       1395
       1395
       +
       createGitRepo .

     

       1396
       1396
       +
       echo a > .gitignore

     

       1397
       1397
       +
       touch a

     

       1398
       1398
       +
       git add -A

     

       1399
       1399
       +
       checkGitTracked

     

       1400
       1400
       +
       

     

       1401
       1401
       +
       # Add it regardless (needs -f)

     

       1402
       1402
       +
       git add -f a

     

       1403
       1403
       +
       checkGitTracked

     

       1404
       1404
       +
       rm -rf -- *

     

       1405
       1405
       +
       

     

       1406
       1406
       +
       # Directory

     

       1407
       1407
       +
       createGitRepo .

     

       1408
       1408
       +
       mkdir -p d1/d2/d3

     

       1409
       1409
       +
       touch d1/d2/d3/a

     

       1410
       1410
       +
       git add d1

     

       1411
       1411
       +
       checkGitTracked

     

       1412
       1412
       +
       rm -rf -- *

     

       1413
       1413
       +
       

     

       1414
       1414
       +
       # Submodules

     

       1415
       1415
       +
       createGitRepo .

     

       1416
       1416
       +
       createGitRepo sub

     

       1417
       1417
       +
       

     

       1418
       1418
       +
       # Untracked submodule

     

       1419
       1419
       +
       git -C sub commit -q --allow-empty -m "Empty commit"

     

       1420
       1420
       +
       checkGitTracked

     

       1421
       1421
       +
       

     

       1422
       1422
       +
       # Tracked submodule

     

       1423
       1423
       +
       git submodule add ./sub sub >/dev/null

     

       1424
       1424
       +
       checkGitTracked

     

       1425
       1425
       +
       

     

       1426
       1426
       +
       # Untracked file

     

       1427
       1427
       +
       echo a > sub/a

     

       1428
       1428
       +
       checkGitTracked

     

       1429
       1429
       +
       

     

       1430
       1430
       +
       # Staged file

     

       1431
       1431
       +
       git -C sub add a

     

       1432
       1432
       +
       checkGitTracked

     

       1433
       1433
       +
       

     

       1434
       1434
       +
       # Committed file

     

       1435
       1435
       +
       git -C sub commit -q -m "Add a"

     

       1436
       1436
       +
       checkGitTracked

     

       1437
       1437
       +
       

     

       1438
       1438
       +
       # Changed file

     

       1439
       1439
       +
       echo b > sub/b

     

       1440
       1440
       +
       checkGitTracked

     

       1441
       1441
       +
       

     

       1442
       1442
       +
       # Removed file

     

       1443
       1443
       +
       git -C sub rm -f -q a

     

       1444
       1444
       +
       checkGitTracked

     

       1445
       1445
       +
       

     

       1252
       1446
        
       rm -rf -- *

     

       1253
       1447
        
       

     

       1254
       1448
        
       # TODO: Once we have combinators and a property testing library, derive property tests from https://en.wikipedia.org/wiki/Algebra_of_sets

+2

lib/tests/release.nix

···

       25
       25
        
             ];

     

       26
       26
        
             nativeBuildInputs = [

     

       27
       27
        
               nix

     

       28
       28
       +
               pkgs.gitMinimal

     

       28
       29
        
             ] ++ lib.optional pkgs.stdenv.isLinux pkgs.inotify-tools;

     

       29
       30
        
             strictDeps = true;

     

       30
       31
        
           } ''

     

       31
       32
        
             datadir="${nix}/share"

     

       32
       33
        
             export TEST_ROOT=$(pwd)/test-tmp

     

       34
       34
       +
             export HOME=$(mktemp -d)

     

       33
       35
        
             export NIX_BUILD_HOOK=

     

       34
       36
        
             export NIX_CONF_DIR=$TEST_ROOT/etc

     

       35
       37
        
             export NIX_LOCALSTATE_DIR=$TEST_ROOT/var

+15

maintainers/maintainer-list.nix

···

       8295
       8295
        
           githubId = 18501;

     

       8296
       8296
        
           name = "Julien Langlois";

     

       8297
       8297
        
         };

     

       8298
       8298
       +
         jfly = {

     

       8299
       8299
       +
           name = "Jeremy Fleischman";

     

       8300
       8300
       +
           email = "jeremyfleischman@gmail.com";

     

       8301
       8301
       +
           github = "jfly";

     

       8302
       8302
       +
           githubId = 277474;

     

       8303
       8303
       +
           keys = [{

     

       8304
       8304
       +
             fingerprint = "F1F1 3395 8E8E 9CC4 D9FC  9647 1931 9CD8 416A 642B";

     

       8305
       8305
       +
           }];

     

       8306
       8306
       +
         };

     

       8298
       8307
        
         jfrankenau = {

     

       8299
       8308
        
           email = "johannes@frankenau.net";

     

       8300
       8309
        
           github = "jfrankenau";

     
···

       11208
       11217
        
           github = "matt-snider";

     

       11209
       11218
        
           githubId = 11810057;

     

       11210
       11219
        
           name = "Matt Snider";

     

       11220
       11220
       +
         };

     

       11221
       11221
       +
         matusf = {

     

       11222
       11222
       +
           email = "matus.ferech@gmail.com";

     

       11223
       11223
       +
           github = "matusf";

     

       11224
       11224
       +
           githubId = 18228995;

     

       11225
       11225
       +
           name = "Matúš Ferech";

     

       11211
       11226
        
         };

     

       11212
       11227
        
         maurer = {

     

       11213
       11228
        
           email = "matthew.r.maurer+nix@gmail.com";

+1

nixos/modules/services/monitoring/parsedmarc.nix

···

       301
       301
        
                     description = lib.mdDoc ''

     

       302
       302
        
                       The addresses to send outgoing mail to.

     

       303
       303
        
                     '';

     

       304
       304
       +
                     apply = x: if x == [] then null else lib.concatStringsSep "," x;

     

       304
       305
        
                   };

     

       305
       306
        
                 };

     

       306
       307

+66 -52

nixos/modules/services/web-apps/plantuml-server.nix

···

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

     

       2
       2
        
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       3
        
       let

     

       4
       4
       +
         inherit (lib)

     

       5
       5
       +
           literalExpression

     

       6
       6
       +
           mdDoc

     

       7
       7
       +
           mkEnableOption

     

       8
       8
       +
           mkIf

     

       9
       9
       +
           mkOption

     

       10
       10
       +
           mkPackageOptionMD

     

       11
       11
       +
           mkRemovedOptionModule

     

       12
       12
       +
           types

     

       13
       13
       +
           ;

     

       6
       14
        
       

     

       7
       15
        
         cfg = config.services.plantuml-server;

     

       8
       16
        
       

     

       9
       17
        
       in

     

       10
       18
        
       

     

       11
       19
        
       {

     

       20
       20
       +
         imports = [

     

       21
       21
       +
           (mkRemovedOptionModule [ "services" "plantuml-server" "allowPlantumlInclude" ] "This option has been removed from PlantUML.")

     

       22
       22
       +
         ];

     

       23
       23
       +
       

     

       12
       24
        
         options = {

     

       13
       25
        
           services.plantuml-server = {

     

       14
       14
       -
             enable = mkEnableOption (lib.mdDoc "PlantUML server");

     

       26
       26
       +
             enable = mkEnableOption (mdDoc "PlantUML server");

     

       15
       27
        
       

     

       16
       16
       -
             package = mkOption {

     

       17
       17
       -
               type = types.package;

     

       18
       18
       -
               default = pkgs.plantuml-server;

     

       19
       19
       -
               defaultText = literalExpression "pkgs.plantuml-server";

     

       20
       20
       -
               description = lib.mdDoc "PlantUML server package to use";

     

       21
       21
       -
             };

     

       28
       28
       +
             package = mkPackageOptionMD pkgs "plantuml-server" { };

     

       22
       29
        
       

     

       23
       30
        
             packages = {

     

       24
       24
       -
               jdk = mkOption {

     

       25
       25
       -
                 type = types.package;

     

       26
       26
       -
                 default = pkgs.jdk;

     

       27
       27
       -
                 defaultText = literalExpression "pkgs.jdk";

     

       28
       28
       -
                 description = lib.mdDoc "JDK package to use for the server";

     

       29
       29
       -
               };

     

       30
       30
       -
               jetty = mkOption {

     

       31
       31
       -
                 type = types.package;

     

       32
       32
       -
                 default = pkgs.jetty;

     

       33
       33
       -
                 defaultText = literalExpression "pkgs.jetty";

     

       34
       34
       -
                 description = lib.mdDoc "Jetty package to use for the server";

     

       31
       31
       +
               jdk = mkPackageOptionMD pkgs "jdk" { };

     

       32
       32
       +
               jetty = mkPackageOptionMD pkgs "jetty" {

     

       33
       33
       +
                 default = "jetty_11";

     

       34
       34
       +
                 extraDescription = ''

     

       35
       35
       +
                   At the time of writing (v1.2023.12), PlantUML Server does not support

     

       36
       36
       +
                   Jetty versions higher than 12.x.

     

       37
       37
       +
       

     

       38
       38
       +
                   Jetty 12.x has introduced major breaking changes, see

     

       39
       39
       +
                   <https://github.com/jetty/jetty.project/releases/tag/jetty-12.0.0> and

     

       40
       40
       +
                   <https://eclipse.dev/jetty/documentation/jetty-12/programming-guide/index.html#pg-migration-11-to-12>

     

       41
       41
       +
                 '';

     

       35
       42
        
               };

     

       36
       43
        
             };

     

       37
       44
        
       

     

       38
       45
        
             user = mkOption {

     

       39
       46
        
               type = types.str;

     

       40
       47
        
               default = "plantuml";

     

       41
       41
       -
               description = lib.mdDoc "User which runs PlantUML server.";

     

       48
       48
       +
               description = mdDoc "User which runs PlantUML server.";

     

       42
       49
        
             };

     

       43
       50
        
       

     

       44
       51
        
             group = mkOption {

     

       45
       52
        
               type = types.str;

     

       46
       53
        
               default = "plantuml";

     

       47
       47
       -
               description = lib.mdDoc "Group which runs PlantUML server.";

     

       54
       54
       +
               description = mdDoc "Group which runs PlantUML server.";

     

       48
       55
        
             };

     

       49
       56
        
       

     

       50
       57
        
             home = mkOption {

     

       51
       51
       -
               type = types.str;

     

       58
       58
       +
               type = types.path;

     

       52
       59
        
               default = "/var/lib/plantuml";

     

       53
       53
       -
               description = lib.mdDoc "Home directory of the PlantUML server instance.";

     

       60
       60
       +
               description = mdDoc "Home directory of the PlantUML server instance.";

     

       54
       61
        
             };

     

       55
       62
        
       

     

       56
       63
        
             listenHost = mkOption {

     

       57
       64
        
               type = types.str;

     

       58
       65
        
               default = "127.0.0.1";

     

       59
       59
       -
               description = lib.mdDoc "Host to listen on.";

     

       66
       66
       +
               description = mdDoc "Host to listen on.";

     

       60
       67
        
             };

     

       61
       68
        
       

     

       62
       69
        
             listenPort = mkOption {

     

       63
       70
        
               type = types.int;

     

       64
       71
        
               default = 8080;

     

       65
       65
       -
               description = lib.mdDoc "Port to listen on.";

     

       72
       72
       +
               description = mdDoc "Port to listen on.";

     

       66
       73
        
             };

     

       67
       74
        
       

     

       68
       75
        
             plantumlLimitSize = mkOption {

     

       69
       76
        
               type = types.int;

     

       70
       77
        
               default = 4096;

     

       71
       71
       -
               description = lib.mdDoc "Limits image width and height.";

     

       78
       78
       +
               description = mdDoc "Limits image width and height.";

     

       72
       79
        
             };

     

       73
       80
        
       

     

       74
       74
       -
             graphvizPackage = mkOption {

     

       75
       75
       -
               type = types.package;

     

       76
       76
       -
               default = pkgs.graphviz;

     

       77
       77
       -
               defaultText = literalExpression "pkgs.graphviz";

     

       78
       78
       -
               description = lib.mdDoc "Package containing the dot executable.";

     

       79
       79
       -
             };

     

       81
       81
       +
             graphvizPackage = mkPackageOptionMD pkgs "graphviz" { };

     

       80
       82
        
       

     

       81
       83
        
             plantumlStats = mkOption {

     

       82
       84
        
               type = types.bool;

     

       83
       85
        
               default = false;

     

       84
       84
       -
               description = lib.mdDoc "Set it to on to enable statistics report (https://plantuml.com/statistics-report).";

     

       86
       86
       +
               description = mdDoc "Set it to on to enable statistics report (https://plantuml.com/statistics-report).";

     

       85
       87
        
             };

     

       86
       88
        
       

     

       87
       89
        
             httpAuthorization = mkOption {

     

       88
       90
        
               type = types.nullOr types.str;

     

       89
       91
        
               default = null;

     

       90
       90
       -
               description = lib.mdDoc "When calling the proxy endpoint, the value of HTTP_AUTHORIZATION will be used to set the HTTP Authorization header.";

     

       91
       91
       -
             };

     

       92
       92
       -
       

     

       93
       93
       -
             allowPlantumlInclude = mkOption {

     

       94
       94
       -
               type = types.bool;

     

       95
       95
       -
               default = false;

     

       96
       96
       -
               description = lib.mdDoc "Enables !include processing which can read files from the server into diagrams. Files are read relative to the current working directory.";

     

       92
       92
       +
               description = mdDoc "When calling the proxy endpoint, the value of HTTP_AUTHORIZATION will be used to set the HTTP Authorization header.";

     

       97
       93
        
             };

     

       98
       94
        
           };

     

       99
       95
        
         };

     

       100
       96
        
       

     

       101
       97
        
         config = mkIf cfg.enable {

     

       102
       102
       -
           users.users.${cfg.user} = {

     

       103
       103
       -
             isSystemUser = true;

     

       104
       104
       -
             group = cfg.group;

     

       105
       105
       -
             home = cfg.home;

     

       106
       106
       -
             createHome = true;

     

       107
       107
       -
           };

     

       108
       108
       -
       

     

       109
       109
       -
           users.groups.${cfg.group} = {};

     

       110
       110
       -
       

     

       111
       98
        
           systemd.services.plantuml-server = {

     

       112
       99
        
             description = "PlantUML server";

     

       113
       100
        
             wantedBy = [ "multi-user.target" ];

     

       114
       101
        
             path = [ cfg.home ];

     

       102
       102
       +
       

     

       115
       103
        
             environment = {

     

       116
       104
        
               PLANTUML_LIMIT_SIZE = builtins.toString cfg.plantumlLimitSize;

     

       117
       105
        
               GRAPHVIZ_DOT = "${cfg.graphvizPackage}/bin/dot";

     

       118
       106
        
               PLANTUML_STATS = if cfg.plantumlStats then "on" else "off";

     

       119
       107
        
               HTTP_AUTHORIZATION = cfg.httpAuthorization;

     

       120
       120
       -
               ALLOW_PLANTUML_INCLUDE = if cfg.allowPlantumlInclude then "true" else "false";

     

       121
       108
        
             };

     

       122
       109
        
             script = ''

     

       123
       110
        
             ${cfg.packages.jdk}/bin/java \

     
···

       128
       115
        
                 jetty.http.host=${cfg.listenHost} \

     

       129
       116
        
                 jetty.http.port=${builtins.toString cfg.listenPort}

     

       130
       117
        
             '';

     

       118
       118
       +
       

     

       131
       119
        
             serviceConfig = {

     

       132
       120
        
               User = cfg.user;

     

       133
       121
        
               Group = cfg.group;

     

       122
       122
       +
               StateDirectory = mkIf (cfg.home == "/var/lib/plantuml") "plantuml";

     

       123
       123
       +
               StateDirectoryMode = mkIf (cfg.home == "/var/lib/plantuml") "0750";

     

       124
       124
       +
       

     

       125
       125
       +
               # Hardening

     

       126
       126
       +
               AmbientCapabilities = [ "" ];

     

       127
       127
       +
               CapabilityBoundingSet = [ "" ];

     

       128
       128
       +
               DynamicUser = true;

     

       129
       129
       +
               LockPersonality = true;

     

       130
       130
       +
               NoNewPrivileges = true;

     

       131
       131
       +
               PrivateDevices = true;

     

       132
       132
       +
               PrivateNetwork = false;

     

       134
       133
        
               PrivateTmp = true;

     

       134
       134
       +
               PrivateUsers = true;

     

       135
       135
       +
               ProtectClock = true;

     

       136
       136
       +
               ProtectControlGroups = true;

     

       137
       137
       +
               ProtectHome = true;

     

       138
       138
       +
               ProtectHostname = true;

     

       139
       139
       +
               ProtectKernelLogs = true;

     

       140
       140
       +
               ProtectKernelModules = true;

     

       141
       141
       +
               ProtectKernelTunables = true;

     

       142
       142
       +
               ProtectSystem = "strict";

     

       143
       143
       +
               RestrictAddressFamilies = [ "AF_UNIX" "AF_INET" "AF_INET6" ];

     

       144
       144
       +
               RestrictNamespaces = true;

     

       145
       145
       +
               RestrictRealtime = true;

     

       146
       146
       +
               RestrictSUIDSGID = true;

     

       147
       147
       +
               SystemCallArchitectures = "native";

     

       148
       148
       +
               SystemCallFilter = [ "@system-service" ];

     

       135
       149
        
             };

     

       136
       150
        
           };

     

       137
       151
        
         };

     

       138
       152
        
       

     

       139
       139
       -
         meta.maintainers = with lib.maintainers; [ truh ];

     

       153
       153
       +
         meta.maintainers = with lib.maintainers; [ truh anthonyroussel ];

     

       140
       154
        
       }

+1

nixos/tests/all-tests.nix

···

       656
       656
        
         phylactery = handleTest ./web-apps/phylactery.nix {};

     

       657
       657
        
         pict-rs = handleTest ./pict-rs.nix {};

     

       658
       658
        
         pinnwand = handleTest ./pinnwand.nix {};

     

       659
       659
       +
         plantuml-server = handleTest ./plantuml-server.nix {};

     

       659
       660
        
         plasma-bigscreen = handleTest ./plasma-bigscreen.nix {};

     

       660
       661
        
         plasma5 = handleTest ./plasma5.nix {};

     

       661
       662
        
         plasma5-systemd-start = handleTest ./plasma5-systemd-start.nix {};

+20

nixos/tests/plantuml-server.nix

···

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

     

       2
       2
       +
         name = "plantuml-server";

     

       3
       3
       +
         meta.maintainers = with lib.maintainers; [ anthonyroussel ];

     

       4
       4
       +
       

     

       5
       5
       +
         nodes.machine = { pkgs, ... }: {

     

       6
       6
       +
           environment.systemPackages = [ pkgs.curl ];

     

       7
       7
       +
           services.plantuml-server.enable = true;

     

       8
       8
       +
         };

     

       9
       9
       +
       

     

       10
       10
       +
         testScript = ''

     

       11
       11
       +
           start_all()

     

       12
       12
       +
       

     

       13
       13
       +
           machine.wait_for_unit("plantuml-server.service")

     

       14
       14
       +
           machine.wait_for_open_port(8080)

     

       15
       15
       +
       

     

       16
       16
       +
           with subtest("Generate chart"):

     

       17
       17
       +
             chart_id = machine.succeed("curl -sSf http://localhost:8080/plantuml/coder -d 'Alice -> Bob'")

     

       18
       18
       +
             machine.succeed("curl -sSf http://localhost:8080/plantuml/txt/{}".format(chart_id))

     

       19
       19
       +
         '';

     

       20
       20
       +
       })

+2 -2

pkgs/applications/audio/galaxy-buds-client/default.nix

···

       13
       13
        
       

     

       14
       14
        
       buildDotnetModule rec {

     

       15
       15
        
         pname = "galaxy-buds-client";

     

       16
       16
       -
         version = "4.5.2";

     

       16
       16
       +
         version = "4.5.4";

     

       17
       17
        
       

     

       18
       18
        
         src = fetchFromGitHub {

     

       19
       19
        
           owner = "ThePBone";

     

       20
       20
        
           repo = "GalaxyBudsClient";

     

       21
       21
        
           rev = version;

     

       22
       22
       -
           hash = "sha256-bnJ1xvqos+JP0KF8Z7mX8/8IozcaRCgaRL3cSO3V120=";

     

       22
       22
       +
           hash = "sha256-mmhXTtESjc8uNULc9zV2Qy/815BEEL7ybdnjArF2CXY=";

     

       23
       23
        
         };

     

       24
       24
        
       

     

       25
       25
        
         projectFile = [ "GalaxyBudsClient/GalaxyBudsClient.csproj" ];

+42 -27

pkgs/applications/audio/galaxy-buds-client/deps.nix

···

       2
       2
        
       # Please dont edit it manually, your changes might get overwritten!

     

       3
       3
        
       

     

       4
       4
        
       { fetchNuGet }: [

     

       5
       5
       -
         (fetchNuGet { pname = "Avalonia"; version = "0.10.14"; sha256 = "0nn3xgkf7v47dwpnsxjg0b25ifqa4mbq02ja5rvnlc3q2k6k0fxv"; })

     

       5
       5
       +
         (fetchNuGet { pname = "Avalonia"; version = "0.10.18"; sha256 = "01x7fc8rdkzba40piwi1ngsk7f8jawzn5bcq2la96hphsiahaarh"; })

     

       6
       6
        
         (fetchNuGet { pname = "Avalonia.Angle.Windows.Natives"; version = "2.1.0.2020091801"; sha256 = "04jm83cz7vkhhr6n2c9hya2k8i2462xbf6np4bidk55as0jdq43a"; })

     

       7
       7
       -
         (fetchNuGet { pname = "Avalonia.Controls.DataGrid"; version = "0.10.14"; sha256 = "0diw3l2nblapvvhnpl28fcgmqg845rlp8cszcvzhd8g6mcm54r7i"; })

     

       8
       8
       -
         (fetchNuGet { pname = "Avalonia.Desktop"; version = "0.10.14"; sha256 = "0r0p1g80pj06d8i7mq0kj00bpnsdlrxkh31r9166c779in34y946"; })

     

       9
       9
       -
         (fetchNuGet { pname = "Avalonia.Diagnostics"; version = "0.10.14"; sha256 = "133w2s2jrjj8731s7xq06c8b4zwn00lb7cn8c1iypqaa82krvkq2"; })

     

       10
       10
       -
         (fetchNuGet { pname = "Avalonia.FreeDesktop"; version = "0.10.14"; sha256 = "06v18kmq10z5gmdqpnvn3aws2ir14gnnz0gvkbj7f68bfggzcg3s"; })

     

       11
       11
       -
         (fetchNuGet { pname = "Avalonia.Markup.Xaml.Loader"; version = "0.10.14"; sha256 = "1qmggiigsn2rkqr0fhrfvyx138dvazihj64r1s4azq014530r0pk"; })

     

       12
       12
       -
         (fetchNuGet { pname = "Avalonia.Native"; version = "0.10.14"; sha256 = "1h0h20cq6hds2mljn1457s42n6pcq821l1d6da2ijncmhk6rdwnl"; })

     

       13
       13
       -
         (fetchNuGet { pname = "Avalonia.Remote.Protocol"; version = "0.10.14"; sha256 = "1hnski71ynqqlddfnbhall4fx3ndh04774kzykzparm8nd9aqaam"; })

     

       14
       14
       -
         (fetchNuGet { pname = "Avalonia.Skia"; version = "0.10.13"; sha256 = "0k5y0w164m03q278m4wr7zzf3vfq9nb0am9vmmprivpn1xwwa7ml"; })

     

       15
       15
       -
         (fetchNuGet { pname = "Avalonia.Skia"; version = "0.10.14"; sha256 = "1cvyg94avqdscniszshx5r3vfvx0cnna262sp89ad4bianmd4qkj"; })

     

       16
       16
       -
         (fetchNuGet { pname = "Avalonia.Svg.Skia"; version = "0.10.13"; sha256 = "1msrsxzya1l0grfxk17yizfvy2vg4i7hyw1aw54s8gf7x3gpzn86"; })

     

       17
       17
       -
         (fetchNuGet { pname = "Avalonia.Win32"; version = "0.10.14"; sha256 = "1c1jdxsnqrzwrcalrvc7x34x1zxc5qcpfxx4fkqca99ngw4b0blj"; })

     

       18
       18
       -
         (fetchNuGet { pname = "Avalonia.X11"; version = "0.10.14"; sha256 = "182nza6rqndxlwi089r06ladfc6j8vsgqzd7xq21s91zbcbcidar"; })

     

       19
       19
       -
         (fetchNuGet { pname = "Avalonia.Xaml.Behaviors"; version = "0.10.13"; sha256 = "0cs42z2vz679mdic7fbxzjs53xm2lp37wcnh843nz86qvma5280k"; })

     

       20
       20
       -
         (fetchNuGet { pname = "Avalonia.Xaml.Interactions"; version = "0.10.13"; sha256 = "0s5fcsy2hs2wphd5cs4dnk4aw8zs5bbzisg0ba5akqpzwpps8fs1"; })

     

       21
       21
       -
         (fetchNuGet { pname = "Avalonia.Xaml.Interactivity"; version = "0.10.13"; sha256 = "19kxbgs0nbiw9zq1f9fsawnw0sl5c880z2dfidnjp99vvfda9rzs"; })

     

       7
       7
       +
         (fetchNuGet { pname = "Avalonia.Controls.DataGrid"; version = "0.10.18"; sha256 = "1qbb527jvhv2p8dcxi7lhm3lczy96j546gb5w09gh90dmzaq45bw"; })

     

       8
       8
       +
         (fetchNuGet { pname = "Avalonia.Desktop"; version = "0.10.18"; sha256 = "0iaby5696km0yl0bs2a8i6a5ypras54mimnmh9wjwarwniqj8yjs"; })

     

       9
       9
       +
         (fetchNuGet { pname = "Avalonia.Diagnostics"; version = "0.10.18"; sha256 = "1qsrzv1fz73p46p9v60qqds229znfv9hawnams5hxwl46jn2v9cp"; })

     

       10
       10
       +
         (fetchNuGet { pname = "Avalonia.FreeDesktop"; version = "0.10.18"; sha256 = "173apfayxkm3lgj7xk9xzsbxmdhv44svr49ccqnd1dii7y69bgny"; })

     

       11
       11
       +
         (fetchNuGet { pname = "Avalonia.Markup.Xaml.Loader"; version = "0.10.18"; sha256 = "0vcbhwckzxgcq9wxim91zk30kzjaydr9szl4rbr3rz85447hj9pi"; })

     

       12
       12
       +
         (fetchNuGet { pname = "Avalonia.Native"; version = "0.10.18"; sha256 = "1hvmjs7wfcbycviky79g1p5q3bzs8j31sr53nnqxqy6pnbmg0nxg"; })

     

       13
       13
       +
         (fetchNuGet { pname = "Avalonia.Remote.Protocol"; version = "0.10.18"; sha256 = "0phxxz4r1llklvp4svy9qlsms3qw77crai3ww70g03fifmmr9qq2"; })

     

       14
       14
       +
         (fetchNuGet { pname = "Avalonia.Skia"; version = "0.10.16"; sha256 = "1rla042nc9mc36qnpipszrf0sffwi5d83cr9dmihpa015bby42pz"; })

     

       15
       15
       +
         (fetchNuGet { pname = "Avalonia.Skia"; version = "0.10.18"; sha256 = "1vi83d9q6m2zd7b5snyzjxsj3vdp5bmi5vqhfslzghslpbhj2zwv"; })

     

       16
       16
       +
         (fetchNuGet { pname = "Avalonia.Svg.Skia"; version = "0.10.16"; sha256 = "1gsm421gzzymc6rys4sw4hds33grg2mwpnm5xpbhwfh4bnbfblg8"; })

     

       17
       17
       +
         (fetchNuGet { pname = "Avalonia.Win32"; version = "0.10.18"; sha256 = "1rvqydbzdi2n6jw4xx9q8i025w5zsgcli9vmv0vw1d51rd4cnc4k"; })

     

       18
       18
       +
         (fetchNuGet { pname = "Avalonia.X11"; version = "0.10.18"; sha256 = "0bzhbnz0dimxbpjxcrphnjn8nk37hqw0b83s2nsha4gzqvpc75b2"; })

     

       19
       19
       +
         (fetchNuGet { pname = "Avalonia.Xaml.Behaviors"; version = "0.10.17"; sha256 = "05g761may9xa1n75lmzib5hknjk7k0nz453bmg2d5m0xxqw6yc13"; })

     

       20
       20
       +
         (fetchNuGet { pname = "Avalonia.Xaml.Interactions"; version = "0.10.17"; sha256 = "0k0xnbayplndc6xld98jdla8zv769aj5s285cpbdgm2dril0rywj"; })

     

       21
       21
       +
         (fetchNuGet { pname = "Avalonia.Xaml.Interactivity"; version = "0.10.17"; sha256 = "0smxxr0b8585x0fq57y3jcaxpl5qyxmkr0c6pd83bsczk8p4rjfy"; })

     

       22
       22
        
         (fetchNuGet { pname = "Castle.Core"; version = "4.4.0"; sha256 = "0rpcbmyhckvlvp6vbzpj03c1gqz56ixc6f15vgmxmyf1g40c24pf"; })

     

       23
       23
        
         (fetchNuGet { pname = "Config.Net"; version = "4.15.0"; sha256 = "0hsyma0r8hssz2h7bx38rr8ajx28x5ya2h4k665cbd65z3cs1di1"; })

     

       24
       24
        
         (fetchNuGet { pname = "Config.Net.Json"; version = "4.15.0"; sha256 = "1q6v4pj76h0hhn26ln4kc8vg75jm8jnlp1ssnrqzwxy88yf82z4h"; })

     

       25
       25
        
         (fetchNuGet { pname = "CS-Script.Core"; version = "1.4.2-preview"; sha256 = "0djliiixl3ncc1b29s9knal1ascg359na0pacsm73p98ad1f7pzh"; })

     

       26
       26
       -
         (fetchNuGet { pname = "Fizzler"; version = "1.2.0"; sha256 = "1b8kvqli5wql53ab9fwyg78h572z4f286s8rjb9xxmsyav1hsyll"; })

     

       26
       26
       +
         (fetchNuGet { pname = "ExCSS"; version = "4.1.4"; sha256 = "1y50xp6rihkydbf5l73mr3qq2rm6rdfjrzdw9h1dw9my230q5lpd"; })

     

       27
       27
       +
         (fetchNuGet { pname = "Fizzler"; version = "1.2.1"; sha256 = "1w5jb1d0figbv68dydbnlcsfmqlc3sv9z1zxp7d79dg2dkarc4qm"; })

     

       27
       28
        
         (fetchNuGet { pname = "HarfBuzzSharp"; version = "2.8.2-preview.178"; sha256 = "1p5nwzl7jpypsd6df7hgcf47r977anjlyv21wacmalsj6lvdgnvn"; })

     

       29
       29
       +
         (fetchNuGet { pname = "HarfBuzzSharp"; version = "2.8.2.1-preview.1"; sha256 = "1g5g7mnfr668hww9r84pfl04x0s44cq5ppykqg406a0lkdb2g8yp"; })

     

       30
       30
       +
         (fetchNuGet { pname = "HarfBuzzSharp"; version = "2.8.2.1-preview.108"; sha256 = "0xs4px4fy5b6glc77rqswzpi5ddhxvbar1md6q9wla7hckabnq0z"; })

     

       28
       31
        
         (fetchNuGet { pname = "HarfBuzzSharp.NativeAssets.Linux"; version = "2.8.2-preview.178"; sha256 = "1402ylkxbgcnagcarqlfvg4gppy2pqs3bmin4n5mphva1g7bqb2p"; })

     

       32
       32
       +
         (fetchNuGet { pname = "HarfBuzzSharp.NativeAssets.Linux"; version = "2.8.2.1-preview.108"; sha256 = "16wvgvyra2g1b38rxxgkk85wbz89hspixs54zfcm4racgmj1mrj4"; })

     

       29
       33
        
         (fetchNuGet { pname = "HarfBuzzSharp.NativeAssets.macOS"; version = "2.8.2-preview.178"; sha256 = "0p8miaclnbfpacc1jaqxwfg0yfx9byagi4j4k91d9621vd19i8b2"; })

     

       34
       34
       +
         (fetchNuGet { pname = "HarfBuzzSharp.NativeAssets.macOS"; version = "2.8.2.1-preview.1"; sha256 = "0z0fadsicysa77ji4fnjkaaqfpc0d1w7x9qlkq40kb3jg7xhsmyx"; })

     

       35
       35
       +
         (fetchNuGet { pname = "HarfBuzzSharp.NativeAssets.macOS"; version = "2.8.2.1-preview.108"; sha256 = "16v7lrwwif2f5zfkx08n6y6w3m56mh4hy757biv0w9yffaf200js"; })

     

       30
       36
        
         (fetchNuGet { pname = "HarfBuzzSharp.NativeAssets.WebAssembly"; version = "2.8.2-preview.178"; sha256 = "1n9jay9sji04xly6n8bzz4591fgy8i65p21a8mv5ip9lsyj1c320"; })

     

       37
       37
       +
         (fetchNuGet { pname = "HarfBuzzSharp.NativeAssets.WebAssembly"; version = "2.8.2.1-preview.108"; sha256 = "15kqb353snwpavz3jja63mq8xjqsrw1f902scm8wxmsqrm5q6x55"; })

     

       31
       38
        
         (fetchNuGet { pname = "HarfBuzzSharp.NativeAssets.Win32"; version = "2.8.2-preview.178"; sha256 = "1r5syii96wv8q558cvsqw3lr10cdw6677lyiy82p6i3if51v3mr7"; })

     

       39
       39
       +
         (fetchNuGet { pname = "HarfBuzzSharp.NativeAssets.Win32"; version = "2.8.2.1-preview.1"; sha256 = "15671jvv5j98rkv249nn1fchxcd9gq8b37iwjqbmijig3r4ir718"; })

     

       40
       40
       +
         (fetchNuGet { pname = "HarfBuzzSharp.NativeAssets.Win32"; version = "2.8.2.1-preview.108"; sha256 = "0n6ymn9jqms3mk5hg0ar4y9jmh96myl6q0jimn7ahb1a8viq55k1"; })

     

       32
       41
        
         (fetchNuGet { pname = "InputSimulatorCore"; version = "1.0.5"; sha256 = "1vfqhqjcrpzahhvv5kyh6pk6j5c06wd0b2831y31fbxpdkxhbs2p"; })

     

       33
       42
        
         (fetchNuGet { pname = "JetBrains.Annotations"; version = "10.3.0"; sha256 = "1grdx28ga9fp4hwwpwv354rizm8anfq4lp045q4ss41gvhggr3z8"; })

     

       34
       43
        
         (fetchNuGet { pname = "libsodium"; version = "1.0.18"; sha256 = "15qzl5k31yaaapqlijr336lh4lzz1qqxlimgxy8fdyig8jdmgszn"; })

     
···

       112
       121
        
         (fetchNuGet { pname = "Serilog.Sinks.Debug"; version = "2.0.0"; sha256 = "1i7j870l47gan3gpnnlzkccn5lbm7518cnkp25a3g5gp9l0dbwpw"; })

     

       113
       122
        
         (fetchNuGet { pname = "Serilog.Sinks.File"; version = "5.0.0"; sha256 = "097rngmgcrdfy7jy8j7dq3xaq2qky8ijwg0ws6bfv5lx0f3vvb0q"; })

     

       114
       123
        
         (fetchNuGet { pname = "Serilog.Sinks.Trace"; version = "3.0.0"; sha256 = "10byjmh2s0c13lmnzfw24qmr11kry9hg9y5fib3556y7759qwbqv"; })

     

       115
       115
       -
         (fetchNuGet { pname = "ShimSkiaSharp"; version = "0.5.13"; sha256 = "0gzsiv85g0i8jmjl0nplvljqrgc4y42ds1q0f1x1hdqbnn7vsav2"; })

     

       116
       116
       -
         (fetchNuGet { pname = "SkiaSharp"; version = "2.88.0-preview.178"; sha256 = "062g14s6b2bixanpwihj3asm3jwvfw15mhvzqv6901afrlgzx4nk"; })

     

       117
       117
       -
         (fetchNuGet { pname = "SkiaSharp.HarfBuzz"; version = "2.88.0-preview.178"; sha256 = "1gwk81iq6zipab3dhpwydrqm2mqz67hpx7asvhna3mx0phrp2zqd"; })

     

       118
       118
       -
         (fetchNuGet { pname = "SkiaSharp.NativeAssets.Linux"; version = "2.88.0-preview.178"; sha256 = "07kga1j51l3l302nvf537zg5clf6rflinjy0xd6i06cmhpkf3ksw"; })

     

       119
       119
       -
         (fetchNuGet { pname = "SkiaSharp.NativeAssets.macOS"; version = "2.88.0-preview.178"; sha256 = "14p95nxccs6yq4rn2h9zbb60k0232k6349zdpy31jcfr6gc99cgi"; })

     

       120
       120
       -
         (fetchNuGet { pname = "SkiaSharp.NativeAssets.WebAssembly"; version = "2.88.0-preview.178"; sha256 = "09jmcg5k1vpsal8jfs90mwv0isf2y5wq3h4hd77rv6vffn5ic4sm"; })

     

       121
       121
       -
         (fetchNuGet { pname = "SkiaSharp.NativeAssets.Win32"; version = "2.88.0-preview.178"; sha256 = "0ficil702lv3fvwpngbqh5l85i05l5jafzyh4jprzshr2qbnd8nl"; })

     

       122
       122
       -
         (fetchNuGet { pname = "Svg.Custom"; version = "0.5.13"; sha256 = "1a6rwgwwqg98dhk5hdb38iffa39khcrvfwskl6i5j3xgvgzzq2lx"; })

     

       123
       123
       -
         (fetchNuGet { pname = "Svg.Model"; version = "0.5.13"; sha256 = "0rxm79asyx1dji8x7q1z47mzy6zh8qbgw7py6xfkfj89cai6x4p8"; })

     

       124
       124
       -
         (fetchNuGet { pname = "Svg.Skia"; version = "0.5.13"; sha256 = "1f00mzx7gzfhy42yldi3jzaivsl3byspak22rji86iq0vczz28zg"; })

     

       124
       124
       +
         (fetchNuGet { pname = "ShimSkiaSharp"; version = "0.5.16"; sha256 = "06qf63bx6m18wbhvzfs89m5yl5s08spgg02gr7qy8j36r04k6cc5"; })

     

       125
       125
       +
         (fetchNuGet { pname = "SkiaSharp"; version = "2.88.1-preview.1"; sha256 = "1i1px67hcr9kygmbfq4b9nqzlwm7v2gapsp4isg9i19ax5g8dlhm"; })

     

       126
       126
       +
         (fetchNuGet { pname = "SkiaSharp"; version = "2.88.1-preview.108"; sha256 = "01sm36hdgmcgkai9m09xn2qfz8v7xhh803n8fng8rlxwnw60rgg6"; })

     

       127
       127
       +
         (fetchNuGet { pname = "SkiaSharp.HarfBuzz"; version = "2.88.1-preview.1"; sha256 = "0r14s3zyn3cpic02j80xjh8x6dd8g671f9nfnng5zk1x497qdw3a"; })

     

       128
       128
       +
         (fetchNuGet { pname = "SkiaSharp.NativeAssets.Linux"; version = "2.88.1-preview.1"; sha256 = "1r9qr3civk0ws1z7hg322qyr8yjm10853zfgs03szr2lvdqiy7d1"; })

     

       129
       129
       +
         (fetchNuGet { pname = "SkiaSharp.NativeAssets.Linux"; version = "2.88.1-preview.108"; sha256 = "19jf2jcq2spwbpx3cfdi2a95jf4y8205rh56lmkh8zsxd2k7fjyp"; })

     

       130
       130
       +
         (fetchNuGet { pname = "SkiaSharp.NativeAssets.macOS"; version = "2.88.1-preview.1"; sha256 = "1w55nrwpl42psn6klia5a9aw2j1n25hpw2fdhchypm9f0v2iz24h"; })

     

       131
       131
       +
         (fetchNuGet { pname = "SkiaSharp.NativeAssets.macOS"; version = "2.88.1-preview.108"; sha256 = "1vcpqd7slh2b9gsacpd7mk1266r1xfnkm6230k8chl3ng19qlf15"; })

     

       132
       132
       +
         (fetchNuGet { pname = "SkiaSharp.NativeAssets.WebAssembly"; version = "2.88.1-preview.1"; sha256 = "0mwj2yl4gn40lry03yqkj7sbi1drmm672dv88481sgah4c21lzrq"; })

     

       133
       133
       +
         (fetchNuGet { pname = "SkiaSharp.NativeAssets.WebAssembly"; version = "2.88.1-preview.108"; sha256 = "0a89gqjw8k97arr0kyd0fm3f46k1qamksbnyns9xdlgydjg557dd"; })

     

       134
       134
       +
         (fetchNuGet { pname = "SkiaSharp.NativeAssets.Win32"; version = "2.88.1-preview.1"; sha256 = "1k50abd147pif9z9lkckbbk91ga1vv6k4skjz2n7wpll6fn0fvlv"; })

     

       135
       135
       +
         (fetchNuGet { pname = "SkiaSharp.NativeAssets.Win32"; version = "2.88.1-preview.108"; sha256 = "05g9blprq5msw3wshrgsk19y0fvhjlqiybs1vdyhfmww330jlypn"; })

     

       136
       136
       +
         (fetchNuGet { pname = "Svg.Custom"; version = "0.5.16"; sha256 = "0qp0vmknclaahf1aj8y2jl4xbaq30rf4ia55fpawxi25dfxsa4wy"; })

     

       137
       137
       +
         (fetchNuGet { pname = "Svg.Model"; version = "0.5.16"; sha256 = "0c2hk7wgvd2lbc96jxnkcwmzbbdnwgnhh4km9ijb5248qkghs1b1"; })

     

       138
       138
       +
         (fetchNuGet { pname = "Svg.Skia"; version = "0.5.16"; sha256 = "0ra6svakyg5h6m19ww5yrxl85w8yi3v5vrzqgcnqlvzndk696cyf"; })

     

       125
       139
        
         (fetchNuGet { pname = "System.AppContext"; version = "4.3.0"; sha256 = "1649qvy3dar900z3g817h17nl8jp4ka5vcfmsr05kh0fshn7j3ya"; })

     

       126
       140
        
         (fetchNuGet { pname = "System.Buffers"; version = "4.3.0"; sha256 = "0fgns20ispwrfqll4q1zc1waqcmylb3zc50ys9x8zlwxh9pmd9jy"; })

     

       127
       141
        
         (fetchNuGet { pname = "System.Collections"; version = "4.3.0"; sha256 = "19r4y64dqyrq6k4706dnyhhw7fs24kpp3awak7whzss39dakpxk9"; })

     
···

       154
       168
        
         (fetchNuGet { pname = "System.Linq"; version = "4.3.0"; sha256 = "1w0gmba695rbr80l1k2h4mrwzbzsyfl2z4klmpbsvsg5pm4a56s7"; })

     

       155
       169
        
         (fetchNuGet { pname = "System.Linq.Expressions"; version = "4.3.0"; sha256 = "0ky2nrcvh70rqq88m9a5yqabsl4fyd17bpr63iy2mbivjs2nyypv"; })

     

       156
       170
        
         (fetchNuGet { pname = "System.Memory"; version = "4.5.3"; sha256 = "0naqahm3wljxb5a911d37mwjqjdxv9l0b49p5dmfyijvni2ppy8a"; })

     

       171
       171
       +
         (fetchNuGet { pname = "System.Memory"; version = "4.5.4"; sha256 = "14gbbs22mcxwggn0fcfs1b062521azb9fbb7c113x0mq6dzq9h6y"; })

     

       157
       172
        
         (fetchNuGet { pname = "System.Net.Http"; version = "4.3.0"; sha256 = "1i4gc757xqrzflbk7kc5ksn20kwwfjhw9w7pgdkn19y3cgnl302j"; })

     

       158
       173
        
         (fetchNuGet { pname = "System.Net.NameResolution"; version = "4.3.0"; sha256 = "15r75pwc0rm3vvwsn8rvm2krf929mjfwliv0mpicjnii24470rkq"; })

     

       159
       174
        
         (fetchNuGet { pname = "System.Net.Primitives"; version = "4.3.0"; sha256 = "0c87k50rmdgmxx7df2khd9qj7q35j9rzdmm2572cc55dygmdk3ii"; })

+2 -1

pkgs/applications/editors/tweak/default.nix

···

       11
       11
        
       

     

       12
       12
        
         buildInputs = [ ncurses ];

     

       13
       13
        
         preBuild = "substituteInPlace Makefile --replace '$(DESTDIR)/usr/local' $out";

     

       14
       14
       +
         makeFlags = [ "CC:=$(CC)" "LINK:=$(CC)" ];

     

       14
       15
        
       

     

       15
       16
        
         meta = with lib; {

     

       16
       17
        
           description = "An efficient hex editor";

     

       17
       18
        
           homepage = "http://www.chiark.greenend.org.uk/~sgtatham/tweak";

     

       18
       19
        
           license = licenses.mit;

     

       19
       19
       -
           platforms = platforms.linux;

     

       20
       20
       +
           platforms = platforms.unix;

     

       20
       21
        
         };

     

       21
       22
        
       }

+2 -2

pkgs/applications/editors/vscode/extensions/default.nix

···

       343
       343
        
               mktplcRef = {

     

       344
       344
        
                 name = "vscode-neovim";

     

       345
       345
        
                 publisher = "asvetliakov";

     

       346
       346
       -
                 version = "0.8.2";

     

       347
       347
       -
                 sha256 = "0kw9asv91s37ql61blbb8pr7wb6c2ba1klchal53chp6ib55v5kn";

     

       346
       346
       +
                 version = "1.0.1";

     

       347
       347
       +
                 sha256 = "1yf065syb5hskds47glnv18nk0fg7d84w1j72hg1pqb082gn1sdv";

     

       348
       348
        
               };

     

       349
       349
        
               meta = {

     

       350
       350
        
                 changelog = "https://marketplace.visualstudio.com/items/asvetliakov.vscode-neovim/changelog";

+3 -3

pkgs/applications/misc/cherrytree/default.nix

···

       20
       20
        
       

     

       21
       21
        
       stdenv.mkDerivation rec {

     

       22
       22
        
         pname = "cherrytree";

     

       23
       23
       -
         version = "1.0.1";

     

       23
       23
       +
         version = "1.0.2";

     

       24
       24
        
       

     

       25
       25
        
         src = fetchFromGitHub {

     

       26
       26
        
           owner = "giuspen";

     

       27
       27
        
           repo = "cherrytree";

     

       28
       28
       -
           rev = version;

     

       29
       29
       -
           hash = "sha256-A/4OcsAOECgQnENj2l9BX713KHG+zk5cJE+yyHXw1TM=";

     

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

     

       29
       29
       +
           hash = "sha256-ZGw6gESKaio89mt3VPm/uqHwlUQ0/8vIydv/WsOYQ20=";

     

       30
       30
        
         };

     

       31
       31
        
       

     

       32
       32
        
         nativeBuildInputs = [

+3 -3

pkgs/applications/misc/spicetify-cli/default.nix

···

       2
       2
        
       

     

       3
       3
        
       buildGoModule rec {

     

       4
       4
        
         pname = "spicetify-cli";

     

       5
       5
       -
         version = "2.27.0";

     

       5
       5
       +
         version = "2.27.1";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "spicetify";

     

       9
       9
        
           repo = "spicetify-cli";

     

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

     

       11
       11
       -
           hash = "sha256-5WIITzm9yZWB847WHL+okwpULdwHegtZfvsVrAzwTO0=";

     

       11
       11
       +
           hash = "sha256-Z+paJAuzUnCdCSx2UHg1HV14vDo3jWsyUrcbEnvqTm0=";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
       -
         vendorHash = "sha256-VktAO3yKCdm5yz/RRLeLv6zzyGrwuHC/i8WdJtqZoYc=";

     

       14
       14
       +
         vendorHash = "sha256-H2kSTsYiD9HResHes+7YxUyNcjtM0SLpDPUC0Y518VM=";

     

       15
       15
        
       

     

       16
       16
        
         ldflags = [

     

       17
       17
        
           "-s -w"

+3 -3

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

···

       10
       10
        
       

     

       11
       11
        
       buildGoModule rec {

     

       12
       12
        
         pname = "werf";

     

       13
       13
       -
         version = "1.2.267";

     

       13
       13
       +
         version = "1.2.269";

     

       14
       14
        
       

     

       15
       15
        
         src = fetchFromGitHub {

     

       16
       16
        
           owner = "werf";

     

       17
       17
        
           repo = "werf";

     

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

     

       19
       19
       -
           hash = "sha256-OlTlyo/JbmXyoMBSDnKHvjGN6NMRrk0kQT63R34gtOs=";

     

       19
       19
       +
           hash = "sha256-LUHENANM+3wGftTVXaQsGykKayzEAIQ3TQ5qM77TJVA=";

     

       20
       20
        
         };

     

       21
       21
        
       

     

       22
       22
       -
         vendorHash = "sha256-0bxM0Y4K6wxg6Ka1A9MusptiSMshTUWJItXoVDpo7lI=";

     

       22
       22
       +
         vendorHash = "sha256-20bPsBRya7Gg7p/hSSnnYLoSHf/fRwk1UrA/KlMT3Jk=";

     

       23
       23
        
       

     

       24
       24
        
         proxyVendor = true;

     

       25
       25

+2 -2

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

···

       4
       4
        
       in

     

       5
       5
        
       stdenv.mkDerivation rec {

     

       6
       6
        
         pname = "rocketchat-desktop";

     

       7
       7
       -
         version = "3.9.9";

     

       7
       7
       +
         version = "3.9.10";

     

       8
       8
        
       

     

       9
       9
        
         src = fetchurl {

     

       10
       10
        
           url = "https://github.com/RocketChat/Rocket.Chat.Electron/releases/download/${version}/rocketchat-${version}-linux-amd64.deb";

     

       11
       11
       -
           hash = "sha256-50mVmE+q2VYJXIv2iD6ppS83We0aJRT9vje+zpJcdq0=";

     

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

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         nativeBuildInputs = [

+2 -2

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

···

       103
       103
        
       in

     

       104
       104
        
       stdenv.mkDerivation rec {

     

       105
       105
        
         pname = "telegram-desktop";

     

       106
       106
       -
         version = "4.11.6";

     

       106
       106
       +
         version = "4.11.8";

     

       107
       107
        
       

     

       108
       108
        
         src = fetchFromGitHub {

     

       109
       109
        
           owner = "telegramdesktop";

     

       110
       110
        
           repo = "tdesktop";

     

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

     

       112
       112
        
           fetchSubmodules = true;

     

       113
       113
       -
           hash = "sha256-GV5jaC1chm4cq097/aP18Z4QemTO4tt8SBrdxCQYaS8=";

     

       113
       113
       +
           hash = "sha256-VuMcqbGo1t1J7I8kXdqsw/01Mth9YKEbiy8aNtM3azw=";

     

       114
       114
        
         };

     

       115
       115
        
       

     

       116
       116
        
         patches = [

+6 -5

pkgs/applications/networking/p2p/rqbit/default.nix pkgs/by-name/rq/rqbit/package.nix

···

       1
       1
       -
       { lib, stdenv, rustPlatform, fetchFromGitHub, pkg-config, openssl, Security }:

     

       1
       1
       +
       { lib, stdenv, rustPlatform, fetchFromGitHub, pkg-config, openssl, darwin }:

     

       2
       2
        
       

     

       3
       3
        
       rustPlatform.buildRustPackage rec {

     

       4
       4
        
         pname = "rqbit";

     

       5
       5
       -
         version = "2.2.1";

     

       5
       5
       +
         version = "2.2.2";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "ikatson";

     

       9
       9
        
           repo = "rqbit";

     

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

     

       11
       11
       -
           hash = "sha256-7n+T+y60RjmZC7bE96Ljg0xVg4bSzV/LFgezTld4zfI=";

     

       11
       11
       +
           hash = "sha256-9yYHxlvRlO8iJ3SPi0+4lEgBgAaqaDffKChqAe4OsYU=";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
       -
         cargoHash = "sha256-hcuZ4hqGJT/O7vFefKPGZlkqhdsAl5LGAcSRQAEopnM=";

     

       14
       14
       +
         cargoHash = "sha256-dUQiW6J3Wycp5D3mAwGwruU6CkQ534OyP1GdsY7jzEw=";

     

       15
       15
        
       

     

       16
       16
        
         nativeBuildInputs = lib.optionals stdenv.isLinux [ pkg-config ];

     

       17
       17
        
       

     

       18
       18
        
         buildInputs = lib.optionals stdenv.isLinux [ openssl ]

     

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

     

       19
       19
       +
           ++ lib.optionals stdenv.isDarwin [ darwin.apple_sdk.frameworks.SystemConfiguration ];

     

       20
       20
        
       

     

       21
       21
        
         doCheck = false;

     

       22
       22
        
       

     
···

       25
       25
        
           homepage = "https://github.com/ikatson/rqbit";

     

       26
       26
        
           license = licenses.asl20;

     

       27
       27
        
           maintainers = with maintainers; [ marsam ];

     

       28
       28
       +
           mainProgram = "rqbit";

     

       28
       29
        
         };

     

       29
       30
        
       }

+3 -3

pkgs/applications/networking/seaweedfs/default.nix

···

       7
       7
        
       

     

       8
       8
        
       buildGoModule rec {

     

       9
       9
        
         pname = "seaweedfs";

     

       10
       10
       -
         version = "3.58";

     

       10
       10
       +
         version = "3.59";

     

       11
       11
        
       

     

       12
       12
        
         src = fetchFromGitHub {

     

       13
       13
        
           owner = "seaweedfs";

     

       14
       14
        
           repo = "seaweedfs";

     

       15
       15
        
           rev = version;

     

       16
       16
       -
           hash = "sha256-4USDCss2KYjyuwH55ZqMwBWsf7iDcjN7qxTSXvKDkus=";

     

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

     

       17
       17
        
         };

     

       18
       18
        
       

     

       19
       19
       -
         vendorHash = "sha256-cbc6xKAneBCWpc4kUQUtgV5rrsggCGvVkt9tkypeCiE=";

     

       19
       19
       +
         vendorHash = "sha256-o+moq4arkQLQZcsW4Tahpv1MpGRHwMv+IL5E03W0U5c=";

     

       20
       20
        
       

     

       21
       21
        
         subPackages = [ "weed" ];

     

       22
       22

+2 -2

pkgs/applications/networking/syncthing/default.nix

···

       13
       13
        
         common = { stname, target, postInstall ? "" }:

     

       14
       14
        
           buildGoModule rec {

     

       15
       15
        
             pname = stname;

     

       16
       16
       -
             version = "1.26.0";

     

       16
       16
       +
             version = "1.26.1";

     

       17
       17
        
       

     

       18
       18
        
             src = fetchFromGitHub {

     

       19
       19
        
               owner = "syncthing";

     

       20
       20
        
               repo = "syncthing";

     

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

     

       22
       22
       -
               hash = "sha256-JsjZzOYBQ5DD7BsBq/lO2AZvC3Rx4mGr5cUJEU6ufNc=";

     

       22
       22
       +
               hash = "sha256-R7JTHlNP1guKRfiDjPVi1lnvfUAXuPDNDAMTGmbj3Hc=";

     

       23
       23
        
             };

     

       24
       24
        
       

     

       25
       25
        
             vendorHash = "sha256-XYXIj+7xe33hCYM6Z9tqGSgr/P0LVlaPNf3T0PrxU7I=";

+5

pkgs/applications/science/electronics/kicad/addons/default.nix

···

       1
       1
       +
       { kicad }:

     

       2
       2
       +
       {

     

       3
       3
       +
         kikit = kicad.callPackage ./kikit.nix { addonName = "kikit"; };

     

       4
       4
       +
         kikit-library = kicad.callPackage ./kikit.nix { addonName = "kikit-library"; };

     

       5
       5
       +
       }

+52

pkgs/applications/science/electronics/kicad/addons/kikit.nix

···

       1
       1
       +
       # For building the multiple addons that are in the kikit repo.

     

       2
       2
       +
       { stdenv

     

       3
       3
       +
       , bc

     

       4
       4
       +
       , kikit

     

       5
       5
       +
       , zip

     

       6
       6
       +
       , python3

     

       7
       7
       +
       , addonName

     

       8
       8
       +
       , addonPath

     

       9
       9
       +
       }:

     

       10
       10
       +
       let

     

       11
       11
       +
         # This python is only used when building the package, it's not the python

     

       12
       12
       +
         # environment that will ultimately run the code packaged here. The python env defined

     

       13
       13
       +
         # in KiCad will import the python code packaged here when KiCad starts up.

     

       14
       14
       +
         python = python3.withPackages (ps: with ps; [ click ]);

     

       15
       15
       +
         kikit-module = python3.pkgs.toPythonModule (kikit.override { inherit python3; });

     

       16
       16
       +
       

     

       17
       17
       +
         # The following different addons can be built from the same source.

     

       18
       18
       +
         targetSpecs = {

     

       19
       19
       +
           "kikit" = {

     

       20
       20
       +
             makeTarget = "pcm-kikit";

     

       21
       21
       +
             resultZip = "pcm-kikit.zip";

     

       22
       22
       +
             description = "KiCad plugin and a CLI tool to automate several tasks in a standard KiCad workflow";

     

       23
       23
       +
           };

     

       24
       24
       +
           "kikit-library" = {

     

       25
       25
       +
             makeTarget = "pcm-lib";

     

       26
       26
       +
             resultZip = "pcm-kikit-lib.zip";

     

       27
       27
       +
             description = "KiKit uses these symbols and footprints to annotate your boards (e.g., to place a tab in a panel).";

     

       28
       28
       +
           };

     

       29
       29
       +
         };

     

       30
       30
       +
         targetSpec = targetSpecs.${addonName};

     

       31
       31
       +
       in

     

       32
       32
       +
       stdenv.mkDerivation {

     

       33
       33
       +
         name = "kicadaddon-${addonName}";

     

       34
       34
       +
         inherit (kikit-module) src version;

     

       35
       35
       +
       

     

       36
       36
       +
         nativeBuildInputs = [ python bc zip ];

     

       37
       37
       +
         propagatedBuildInputs = [ kikit-module ];

     

       38
       38
       +
       

     

       39
       39
       +
         buildPhase = ''

     

       40
       40
       +
           patchShebangs scripts/setJson.py

     

       41
       41
       +
           make ${targetSpec.makeTarget}

     

       42
       42
       +
         '';

     

       43
       43
       +
       

     

       44
       44
       +
         installPhase = ''

     

       45
       45
       +
           mkdir $out

     

       46
       46
       +
           mv build/${targetSpec.resultZip} $out/${addonPath}

     

       47
       47
       +
         '';

     

       48
       48
       +
       

     

       49
       49
       +
         meta = kikit-module.meta // {

     

       50
       50
       +
           description = targetSpec.description;

     

       51
       51
       +
         };

     

       52
       52
       +
       }

+2

pkgs/applications/science/electronics/kicad/base.nix

···

       69
       69
        
         patches = [

     

       70
       70
        
           # upstream issue 12941 (attempted to upstream, but appreciably unacceptable)

     

       71
       71
        
           ./writable.patch

     

       72
       72
       +
           # https://gitlab.com/kicad/code/kicad/-/issues/15687

     

       73
       73
       +
           ./runtime_stock_data_path.patch

     

       72
       74
        
         ];

     

       73
       75
        
       

     

       74
       76
        
         # tagged releases don't have "unknown"

+52 -1

pkgs/applications/science/electronics/kicad/default.nix

···

       1
       1
        
       { lib, stdenv

     

       2
       2
       +
       , runCommand

     

       3
       3
       +
       , newScope

     

       2
       4
        
       , fetchFromGitLab

     

       3
       5
        
       , gnome

     

       4
       6
        
       , dconf

     
···

       11
       13
        
       , callPackages

     

       12
       14
        
       , librsvg

     

       13
       15
        
       , cups

     

       16
       16
       +
       , unzip

     

       17
       17
       +
       , jq

     

       14
       18
        
       

     

       15
       19
        
       , pname ? "kicad"

     

       16
       20
        
       , stable ? true

     
···

       18
       22
        
       , libngspice

     

       19
       23
        
       , withScripting ? true

     

       20
       24
        
       , python3

     

       25
       25
       +
       , addons ? [ ]

     

       21
       26
        
       , debug ? false

     

       22
       27
        
       , sanitizeAddress ? false

     

       23
       28
        
       , sanitizeThreads ? false

     
···

       26
       31
        
       , srcs ? { }

     

       27
       32
        
       , symlinkJoin

     

       28
       33
        
       }:

     

       34
       34
       +
       

     

       35
       35
       +
       # `addons`: https://dev-docs.kicad.org/en/addons/

     

       36
       36
       +
       #

     

       37
       37
       +
       # ```nix

     

       38
       38
       +
       # kicad = pkgs.kicad.override {

     

       39
       39
       +
       #   addons = with pkgs.kicadAddons; [ kikit kikit-library ];

     

       40
       40
       +
       # };

     

       41
       41
       +
       # ```

     

       29
       42
        
       

     

       30
       43
        
       # The `srcs` parameter can be used to override the kicad source code

     

       31
       44
        
       # and all libraries, which are otherwise inaccessible

     
···

       106
       119
        
         wxGTK = wxGTK32;

     

       107
       120
        
         python = python3;

     

       108
       121
        
         wxPython = python.pkgs.wxPython_4_2;

     

       122
       122
       +
         addonPath = "addon.zip";

     

       123
       123
       +
         addonsDrvs = map (pkg: pkg.override { inherit addonPath python3; }) addons;

     

       124
       124
       +
       

     

       125
       125
       +
         addonsJoined =

     

       126
       126
       +
           runCommand "addonsJoined"

     

       127
       127
       +
             {

     

       128
       128
       +
               inherit addonsDrvs;

     

       129
       129
       +
               nativeBuildInputs = [ unzip jq ];

     

       130
       130
       +
             } ''

     

       131
       131
       +
             mkdir $out

     

       132
       132
       +
       

     

       133
       133
       +
             for pkg in $addonsDrvs; do

     

       134
       134
       +
               unzip $pkg/addon.zip -d unpacked

     

       135
       135
       +
       

     

       136
       136
       +
               folder_name=$(jq .identifier unpacked/metadata.json --raw-output | tr . _)

     

       137
       137
       +
               for d in unpacked/*; do

     

       138
       138
       +
                 if [ -d "$d" ]; then

     

       139
       139
       +
                   dest=$out/share/kicad/scripting/$(basename $d)/$folder_name

     

       140
       140
       +
                   mkdir -p $(dirname $dest)

     

       141
       141
       +
       

     

       142
       142
       +
                   mv $d $dest

     

       143
       143
       +
                 fi

     

       144
       144
       +
               done

     

       145
       145
       +
               rm -r unpacked

     

       146
       146
       +
             done

     

       147
       147
       +
           '';

     

       109
       148
        
       

     

       110
       149
        
         inherit (lib) concatStringsSep flatten optionalString optionals;

     

       111
       150
        
       in

     
···

       113
       152
        
       

     

       114
       153
        
         # Common libraries, referenced during runtime, via the wrapper.

     

       115
       154
        
         passthru.libraries = callPackages ./libraries.nix { inherit libSrc; };

     

       155
       155
       +
         passthru.callPackage = newScope { inherit addonPath python3; };

     

       116
       156
        
         base = callPackage ./base.nix {

     

       117
       157
        
           inherit stable baseName;

     

       118
       158
        
           inherit kicadSrc kicadVersion;

     
···

       131
       171
        
         dontFixup = true;

     

       132
       172
        
       

     

       133
       173
        
         pythonPath = optionals (withScripting)

     

       134
       134
       -
           [ wxPython python.pkgs.six python.pkgs.requests ];

     

       174
       174
       +
           [ wxPython python.pkgs.six python.pkgs.requests ] ++ addonsDrvs;

     

       135
       175
        
       

     

       136
       176
        
         nativeBuildInputs = [ makeWrapper ]

     

       137
       177
        
           ++ optionals (withScripting)

     
···

       164
       204
        
           "--set-default KICAD7_SYMBOL_DIR ${symbols}/share/kicad/symbols"

     

       165
       205
        
           "--set-default KICAD7_TEMPLATE_DIR ${template_dir}"

     

       166
       206
        
         ]

     

       207
       207
       +
         ++ optionals (addons != [ ]) (

     

       208
       208
       +
           let stockDataPath = symlinkJoin {

     

       209
       209
       +
             name = "kicad_stock_data_path";

     

       210
       210
       +
             paths = [

     

       211
       211
       +
               "${base}/share/kicad"

     

       212
       212
       +
               "${addonsJoined}/share/kicad"

     

       213
       213
       +
             ];

     

       214
       214
       +
           };

     

       215
       215
       +
           in

     

       216
       216
       +
           [ "--set-default NIX_KICAD7_STOCK_DATA_PATH ${stockDataPath}" ]

     

       217
       217
       +
         )

     

       167
       218
        
         ++ optionals (with3d)

     

       168
       219
        
         [

     

       169
       220
        
           "--set-default KICAD7_3DMODEL_DIR ${packages3d}/share/kicad/3dmodels"

+15

pkgs/applications/science/electronics/kicad/runtime_stock_data_path.patch

···

       1
       1
       +
       diff --git a/common/paths.cpp b/common/paths.cpp

     

       2
       2
       +
       index a74cdd9..790cc58 100644

     

       3
       3
       +
       --- a/common/paths.cpp

     

       4
       4
       +
       +++ b/common/paths.cpp

     

       5
       5
       +
       @@ -151,6 +151,10 @@ wxString PATHS::GetStockDataPath( bool aRespectRunFromBuildDir )

     

       6
       6
       +
        {

     

       7
       7
       +
            wxString path;

     

       8
       8
       +
       

     

       9
       9
       +
       +    if( wxGetEnv( wxT( "NIX_KICAD7_STOCK_DATA_PATH" ), &path ) ) {

     

       10
       10
       +
       +        return path;

     

       11
       11
       +
       +    }

     

       12
       12
       +
       +

     

       13
       13
       +
            if( aRespectRunFromBuildDir && wxGetEnv( wxT( "KICAD_RUN_FROM_BUILD_DIR" ), nullptr ) )

     

       14
       14
       +
            {

     

       15
       15
       +
                // Allow debugging from build dir by placing relevant files/folders in the build root

+3 -3

pkgs/applications/version-management/git-mit/default.nix

···

       10
       10
        
       }:

     

       11
       11
        
       

     

       12
       12
        
       let

     

       13
       13
       -
         version = "5.12.171";

     

       13
       13
       +
         version = "5.12.174";

     

       14
       14
        
       in

     

       15
       15
        
       rustPlatform.buildRustPackage {

     

       16
       16
        
         pname = "git-mit";

     
···

       20
       20
        
           owner = "PurpleBooth";

     

       21
       21
        
           repo = "git-mit";

     

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

     

       23
       23
       -
           hash = "sha256-K2d12isOOPs8ba77VhQSXRHSYLZZIkZJlM9d3/G4nOo=";

     

       23
       23
       +
           hash = "sha256-juCiPulDVDDg9+DXUf9Gp/1lMoQ0NKLUTrzOqlv+32w=";

     

       24
       24
        
         };

     

       25
       25
        
       

     

       26
       26
       -
         cargoHash = "sha256-m5b57dJ6IRJ10eJRF5lj2+WiNswHxj08LgXz7KJiTaw=";

     

       26
       26
       +
         cargoHash = "sha256-Wtw7GBPUci4fbplQDtz1Yxrf+7+3ABIe7GPN/gUER6I=";

     

       27
       27
        
       

     

       28
       28
        
         nativeBuildInputs = [ pkg-config ];

     

       29
       29

+19 -7

pkgs/applications/video/webtorrent_desktop/default.nix

···

       1
       1
       -
       { lib, stdenv, electron_22, buildNpmPackage, fetchFromGitHub }:

     

       1
       1
       +
       { lib, stdenv, electron, buildNpmPackage, fetchFromGitHub, fetchpatch }:

     

       2
       2
        
       

     

       3
       3
        
       buildNpmPackage {

     

       4
       4
        
         pname = "webtorrent-desktop";

     

       5
       5
       -
         version = "0.25-pre";

     

       5
       5
       +
         version = "0.25-pre-1eb612";

     

       6
       6
        
         src = fetchFromGitHub {

     

       7
       7
        
           owner = "webtorrent";

     

       8
       8
        
           repo = "webtorrent-desktop";

     

       9
       9
       -
           rev = "fce078defefd575cb35a5c79d3d9f96affc8a08f";

     

       10
       10
       -
           sha256 = "sha256-gXFiG36qqR0QHTqhaxgQKDO0UCHkJLnVwUTQB/Nct/c=";

     

       9
       9
       +
           rev = "1eb61201d6360698a2cc4ea72bf0fa7ee78b457c";

     

       10
       10
       +
           sha256 = "sha256-DBEFOamncyidMXypvKNnUmDIPUq1LzYjDgox7fa4+Gg=";

     

       11
       11
        
         };

     

       12
       12
       -
         npmDepsHash = "sha256-pEuvstrZ9oMdJ/iU6XwEQ1BYOyQp/ce6sYBTrMCjGMc=";

     

       12
       12
       +
         patches = [

     

       13
       13
       +
           # electron 27 fix

     

       14
       14
       +
           (fetchpatch {

     

       15
       15
       +
             url = "https://github.com/webtorrent/webtorrent-desktop/pull/2388.patch";

     

       16
       16
       +
             hash = "sha256-gam5oAZtsaiCNFwecA5ff0nhraySLx3SOHlb/js+cPM=";

     

       17
       17
       +
           })

     

       18
       18
       +
           # startup fix

     

       19
       19
       +
           (fetchpatch {

     

       20
       20
       +
             url = "https://github.com/webtorrent/webtorrent-desktop/pull/2389.patch";

     

       21
       21
       +
             hash = "sha256-hBJGLNNjcGRhYOFlLm/RL0po+70tEeJtR6Y/CfacPAI=";

     

       22
       22
       +
           })

     

       23
       23
       +
         ];

     

       24
       24
       +
         npmDepsHash = "sha256-tqhp3jDb1xtyV/n9kJtzkiznLQfqeYWeZiTnTVV0ibE=";

     

       13
       25
        
         makeCacheWritable = true;

     

       14
       26
        
         npmRebuildFlags = [ "--ignore-scripts" ];

     

       15
       27
        
         installPhase = ''

     
···

       31
       43
        
           cat > $out/bin/WebTorrent <<EOF

     

       32
       44
        
           #! ${stdenv.shell}

     

       33
       45
        
           set -eu

     

       34
       34
       -
           exec ${electron_22}/bin/electron --no-sandbox $out/lib/webtorrent-desktop "\$@"

     

       46
       46
       +
           exec ${electron}/bin/electron --no-sandbox $out/lib/webtorrent-desktop "\$@"

     

       35
       47
        
           EOF

     

       36
       48
        
           chmod +x $out/bin/WebTorrent

     

       37
       49
        
           cp -r static/linux/share/icons $out/share/

     
···

       44
       56
        
           description = "Streaming torrent app for Mac, Windows, and Linux";

     

       45
       57
        
           homepage = "https://webtorrent.io/desktop";

     

       46
       58
        
           license = licenses.mit;

     

       47
       47
       -
           maintainers = [ maintainers.flokli maintainers.bendlas ];

     

       59
       59
       +
           maintainers = [ maintainers.bendlas ];

     

       48
       60
        
         };

     

       49
       61
        
       

     

       50
       62
        
       }

+3 -4

pkgs/build-support/build-graalvm-native-image/default.nix

···

       3
       3
        
       , glibcLocales

     

       4
       4
        
         # The GraalVM derivation to use

     

       5
       5
        
       , graalvmDrv

     

       6
       6
       -
       , name ? "${args.pname}-${args.version}"

     

       7
       6
        
       , executable ? args.pname

     

       8
       7
        
         # JAR used as input for GraalVM derivation, defaults to src

     

       9
       8
        
       , jar ? args.src

     
···

       15
       14
        
           "-H:Name=${executable}"

     

       16
       15
        
           "-march=compatibility"

     

       17
       16
        
           "--verbose"

     

       17
       17
       +
           "-J-Dsun.stdout.encoding=UTF-8"

     

       18
       18
       +
           "-J-Dsun.stderr.encoding=UTF-8"

     

       18
       19
        
         ]

     

       19
       20
        
         # Extra arguments to be passed to the native-image

     

       20
       21
        
       , extraNativeImageBuildArgs ? [ ]

     

       21
       22
        
         # XMX size of GraalVM during build

     

       22
       23
        
       , graalvmXmx ? "-J-Xmx6g"

     

       23
       23
       -
         # Locale to be used by GraalVM compiler

     

       24
       24
       -
       , LC_ALL ? "en_US.UTF-8"

     

       25
       24
        
       , meta ? { }

     

       26
       25
        
       , ...

     

       27
       26
        
       } @ args:

     
···

       41
       40
        
         ];

     

       42
       41
        
       in

     

       43
       42
        
       stdenv.mkDerivation ({

     

       44
       44
       -
         inherit dontUnpack LC_ALL jar;

     

       43
       43
       +
         inherit dontUnpack jar;

     

       45
       44
        
       

     

       46
       45
        
         nativeBuildInputs = (args.nativeBuildInputs or [ ]) ++ [ graalvmDrv glibcLocales ];

     

       47
       46

+3 -3

pkgs/by-name/as/ast-grep/package.nix

···

       6
       6
        
       

     

       7
       7
        
       rustPlatform.buildRustPackage rec {

     

       8
       8
        
         pname = "ast-grep";

     

       9
       9
       -
         version = "0.12.5";

     

       9
       9
       +
         version = "0.13.1";

     

       10
       10
        
       

     

       11
       11
        
         src = fetchFromGitHub {

     

       12
       12
        
           owner = "ast-grep";

     

       13
       13
        
           repo = "ast-grep";

     

       14
       14
        
           rev = version;

     

       15
       15
       -
           hash = "sha256-oFe3AbMpBVBAm/W4IowXAKcEN7CDrrAXhx4dzMXppUM=";

     

       15
       15
       +
           hash = "sha256-Wee+npgL0+7pv9ph3S93fIXr8z/FWp/TBthJhVSx3zI=";

     

       16
       16
        
         };

     

       17
       17
        
       

     

       18
       18
       -
         cargoHash = "sha256-f4tcJqT3l9G6FimBb0D4PATgQYUkSG5uIQ9BbsbgC/U=";

     

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

     

       19
       19
        
       

     

       20
       20
        
         # error: linker `aarch64-linux-gnu-gcc` not found

     

       21
       21
        
         postPatch = ''

+3 -3

pkgs/by-name/ez/eza/package.nix

···

       17
       17
        
       

     

       18
       18
        
       rustPlatform.buildRustPackage rec {

     

       19
       19
        
         pname = "eza";

     

       20
       20
       -
         version = "0.15.3";

     

       20
       20
       +
         version = "0.16.0";

     

       21
       21
        
       

     

       22
       22
        
         src = fetchFromGitHub {

     

       23
       23
        
           owner = "eza-community";

     

       24
       24
        
           repo = "eza";

     

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

     

       26
       26
       -
           hash = "sha256-V0PuiF8N5ubNO4/EmGFx6qL0k1ziTVVKe+0rpMTMVlg=";

     

       26
       26
       +
           hash = "sha256-q72IIKUWZBroDcxMEa1ppTPda9lg/KtEpCNOqlg9ZhU=";

     

       27
       27
        
         };

     

       28
       28
        
       

     

       29
       29
       -
         cargoHash = "sha256-kO4WxTDVmLlQpYuFbohih+4Hct2AmnO802Veuw2Wj2g=";

     

       29
       29
       +
         cargoHash = "sha256-UBayjaQX+bRkciookfQYUrCCewMXlIL3Z1I2ZJIbX6o=";

     

       30
       30
        
       

     

       31
       31
        
         nativeBuildInputs = [ cmake pkg-config installShellFiles pandoc ];

     

       32
       32
        
         buildInputs = [ zlib ]

+3 -3

pkgs/by-name/fo/fortune-kind/package.nix

···

       11
       11
        
       

     

       12
       12
        
       rustPlatform.buildRustPackage rec {

     

       13
       13
        
         pname = "fortune-kind";

     

       14
       14
       -
         version = "0.1.8";

     

       14
       14
       +
         version = "0.1.9";

     

       15
       15
        
       

     

       16
       16
        
         src = fetchFromGitHub {

     

       17
       17
        
           owner = "cafkafk";

     

       18
       18
        
           repo = "fortune-kind";

     

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

     

       20
       20
       -
           hash = "sha256-8xXRIp6fNYo0Eylzz+i+YccEJZjqiT0TxguZheIblns=";

     

       20
       20
       +
           hash = "sha256-93BEy9FX3bZTYNewotBv1ejmMSnSdu9XnC4TgIvcYG0=";

     

       21
       21
        
         };

     

       22
       22
        
       

     

       23
       23
       -
         cargoHash = "sha256-v1LmZRuknWFAwwuw4U7Y7jnhBi8UkglY0sege9nSKes=";

     

       23
       23
       +
         cargoHash = "sha256-xm6BOYnxUoCRuMAAFyWRcKEcqrs5FmnOgIO/Gj1bCoI=";

     

       24
       24
        
       

     

       25
       25
        
         nativeBuildInputs = [ makeBinaryWrapper installShellFiles ];

     

       26
       26
        
         buildInputs = lib.optionals stdenv.isDarwin [ libiconv darwin.apple_sdk.frameworks.Security ];

+87

pkgs/by-name/ki/kikit/default.nix

···

       1
       1
       +
       { bc

     

       2
       2
       +
       , zip

     

       3
       3
       +
       , lib

     

       4
       4
       +
       , fetchFromGitHub

     

       5
       5
       +
       , bats

     

       6
       6
       +
       , buildPythonApplication

     

       7
       7
       +
       , pythonOlder

     

       8
       8
       +
       , callPackage

     

       9
       9
       +
       , kicad

     

       10
       10
       +
       , numpy

     

       11
       11
       +
       , click

     

       12
       12
       +
       , markdown2

     

       13
       13
       +
       , pytestCheckHook

     

       14
       14
       +
       , commentjson

     

       15
       15
       +
       , wxPython_4_2

     

       16
       16
       +
       , pcbnew-transition

     

       17
       17
       +
       , pybars3

     

       18
       18
       +
       , versioneer

     

       19
       19
       +
       }:

     

       20
       20
       +
       let

     

       21
       21
       +
         solidpython = callPackage ./solidpython { };

     

       22
       22
       +
       

     

       23
       23
       +
         # https://github.com/yaqwsx/KiKit/issues/574

     

       24
       24
       +
         # copy-pasted from nixpkgs#8d8e62e74f511160a599471549a98bc9e4f4818d

     

       25
       25
       +
         shapely = callPackage ./shapely { };

     

       26
       26
       +
       in

     

       27
       27
       +
       buildPythonApplication rec {

     

       28
       28
       +
         pname = "kikit";

     

       29
       29
       +
         version = "1.3.0";

     

       30
       30
       +
         format = "setuptools";

     

       31
       31
       +
       

     

       32
       32
       +
         disabled = pythonOlder "3.7";

     

       33
       33
       +
       

     

       34
       34
       +
         src = fetchFromGitHub {

     

       35
       35
       +
           owner = "yaqwsx";

     

       36
       36
       +
           repo = "KiKit";

     

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

     

       38
       38
       +
           hash = "sha256-kDTPk/R3eZtm4DjoUV4tSQzjGQ9k8MKQedX4oUXYzeo=";

     

       39
       39
       +
         };

     

       40
       40
       +
       

     

       41
       41
       +
         propagatedBuildInputs = [

     

       42
       42
       +
           kicad

     

       43
       43
       +
           numpy

     

       44
       44
       +
           click

     

       45
       45
       +
           markdown2

     

       46
       46
       +
           commentjson

     

       47
       47
       +
           # https://github.com/yaqwsx/KiKit/issues/575

     

       48
       48
       +
           wxPython_4_2

     

       49
       49
       +
           pcbnew-transition

     

       50
       50
       +
           pybars3

     

       51
       51
       +
           shapely

     

       52
       52
       +
           # https://github.com/yaqwsx/KiKit/issues/576

     

       53
       53
       +
           solidpython

     

       54
       54
       +
         ];

     

       55
       55
       +
       

     

       56
       56
       +
         nativeBuildInputs = [

     

       57
       57
       +
           versioneer

     

       58
       58
       +
           bc

     

       59
       59
       +
           zip

     

       60
       60
       +
         ];

     

       61
       61
       +
       

     

       62
       62
       +
         nativeCheckInputs = [

     

       63
       63
       +
           pytestCheckHook

     

       64
       64
       +
           bats

     

       65
       65
       +
         ];

     

       66
       66
       +
       

     

       67
       67
       +
         pythonImportsCheck = [

     

       68
       68
       +
           "kikit"

     

       69
       69
       +
         ];

     

       70
       70
       +
       

     

       71
       71
       +
         preCheck = ''

     

       72
       72
       +
           export PATH=$PATH:$out/bin

     

       73
       73
       +
       

     

       74
       74
       +
           make test-system

     

       75
       75
       +
       

     

       76
       76
       +
           # pytest needs to run in a subdir. See https://github.com/yaqwsx/KiKit/blob/v1.3.0/Makefile#L43

     

       77
       77
       +
           cd test/units

     

       78
       78
       +
         '';

     

       79
       79
       +
       

     

       80
       80
       +
         meta = with lib; {

     

       81
       81
       +
           description = "Automation for KiCAD boards";

     

       82
       82
       +
           homepage = "https://github.com/yaqwsx/KiKit/";

     

       83
       83
       +
           changelog = "https://github.com/yaqwsx/KiKit/releases/tag/v${version}";

     

       84
       84
       +
           maintainers = with maintainers; [ jfly matusf ];

     

       85
       85
       +
           license = licenses.mit;

     

       86
       86
       +
         };

     

       87
       87
       +
       }

+2

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

···

       1
       1
       +
       { python3 }:

     

       2
       2
       +
       (python3.pkgs.callPackage ./default.nix { })

+71

pkgs/by-name/ki/kikit/shapely/default.nix

···

       1
       1
       +
       { lib

     

       2
       2
       +
       , stdenv

     

       3
       3
       +
       , buildPythonPackage

     

       4
       4
       +
       , fetchPypi

     

       5
       5
       +
       , substituteAll

     

       6
       6
       +
       , pythonOlder

     

       7
       7
       +
       , geos

     

       8
       8
       +
       , pytestCheckHook

     

       9
       9
       +
       , cython

     

       10
       10
       +
       , numpy

     

       11
       11
       +
       }:

     

       12
       12
       +
       

     

       13
       13
       +
       buildPythonPackage rec {

     

       14
       14
       +
         pname = "Shapely";

     

       15
       15
       +
         version = "1.8.4";

     

       16
       16
       +
         disabled = pythonOlder "3.6";

     

       17
       17
       +
       

     

       18
       18
       +
         src = fetchPypi {

     

       19
       19
       +
           inherit pname version;

     

       20
       20
       +
           sha256 = "sha256-oZXlHKr6IYKR8suqP+9p/TNTyT7EtlsqRyLEz0DDGYw=";

     

       21
       21
       +
         };

     

       22
       22
       +
       

     

       23
       23
       +
         nativeBuildInputs = [

     

       24
       24
       +
           geos # for geos-config

     

       25
       25
       +
           cython

     

       26
       26
       +
         ];

     

       27
       27
       +
       

     

       28
       28
       +
         propagatedBuildInputs = [

     

       29
       29
       +
           numpy

     

       30
       30
       +
         ];

     

       31
       31
       +
       

     

       32
       32
       +
         checkInputs = [

     

       33
       33
       +
           pytestCheckHook

     

       34
       34
       +
         ];

     

       35
       35
       +
       

     

       36
       36
       +
         # Environment variable used in shapely/_buildcfg.py

     

       37
       37
       +
         GEOS_LIBRARY_PATH = "${geos}/lib/libgeos_c${stdenv.hostPlatform.extensions.sharedLibrary}";

     

       38
       38
       +
       

     

       39
       39
       +
         patches = [

     

       40
       40
       +
           # Patch to search form GOES .so/.dylib files in a Nix-aware way

     

       41
       41
       +
           (substituteAll {

     

       42
       42
       +
             src = ./library-paths.patch;

     

       43
       43
       +
             libgeos_c = GEOS_LIBRARY_PATH;

     

       44
       44
       +
             libc = lib.optionalString (!stdenv.isDarwin) "${stdenv.cc.libc}/lib/libc${stdenv.hostPlatform.extensions.sharedLibrary}.6";

     

       45
       45
       +
           })

     

       46
       46
       +
         ];

     

       47
       47
       +
       

     

       48
       48
       +
         preCheck = ''

     

       49
       49
       +
           rm -r shapely # prevent import of local shapely

     

       50
       50
       +
         '';

     

       51
       51
       +
       

     

       52
       52
       +
         disabledTests = lib.optionals (stdenv.isDarwin && stdenv.isAarch64) [

     

       53
       53
       +
           # FIXME(lf-): these logging tests are broken, which is definitely our

     

       54
       54
       +
           # fault. I've tried figuring out the cause and failed.

     

       55
       55
       +
           #

     

       56
       56
       +
           # It is apparently some sandbox or no-sandbox related thing on macOS only

     

       57
       57
       +
           # though.

     

       58
       58
       +
           "test_error_handler_exception"

     

       59
       59
       +
           "test_error_handler"

     

       60
       60
       +
           "test_info_handler"

     

       61
       61
       +
         ];

     

       62
       62
       +
       

     

       63
       63
       +
         pythonImportsCheck = [ "shapely" ];

     

       64
       64
       +
       

     

       65
       65
       +
         meta = with lib; {

     

       66
       66
       +
           description = "Geometric objects, predicates, and operations";

     

       67
       67
       +
           homepage = "https://pypi.python.org/pypi/Shapely/";

     

       68
       68
       +
           license = with licenses; [ bsd3 ];

     

       69
       69
       +
           maintainers = with maintainers; [ knedlsepp ];

     

       70
       70
       +
         };

     

       71
       71
       +
       }

+31

pkgs/by-name/ki/kikit/shapely/library-paths.patch

···

       1
       1
       +
       diff --git a/shapely/geos.py b/shapely/geos.py

     

       2
       2
       +
       index 88c5f53..1ccd6e4 100644

     

       3
       3
       +
       --- a/shapely/geos.py

     

       4
       4
       +
       +++ b/shapely/geos.py

     

       5
       5
       +
       @@ -96,6 +96,7 @@ if sys.platform.startswith('linux'):

     

       6
       6
       +
                alt_paths = [

     

       7
       7
       +
                    'libgeos_c.so.1',

     

       8
       8
       +
                    'libgeos_c.so',

     

       9
       9
       +
       +            '@libgeos_c@',

     

       10
       10
       +
                ]

     

       11
       11
       +
                _lgeos = load_dll('geos_c', fallbacks=alt_paths)

     

       12
       12
       +
       

     

       13
       13
       +
       @@ -160,6 +161,7 @@ elif sys.platform == 'darwin':

     

       14
       14
       +
                    "/usr/local/lib/libgeos_c.dylib",

     

       15
       15
       +
                    # homebrew Apple Silicon

     

       16
       16
       +
                    "/opt/homebrew/lib/libgeos_c.dylib",

     

       17
       17
       +
       +            "@libgeos_c@",

     

       18
       18
       +
                ]

     

       19
       19
       +
                _lgeos = load_dll('geos_c', fallbacks=alt_paths)

     

       20
       20
       +
       

     

       21
       21
       +
       diff --git a/tests/test_dlls.py b/tests/test_dlls.py

     

       22
       22
       +
       index c71da8e..c36262c 100644

     

       23
       23
       +
       --- a/tests/test_dlls.py

     

       24
       24
       +
       +++ b/tests/test_dlls.py

     

       25
       25
       +
       @@ -18,4 +18,5 @@ class LoadingTestCase(unittest.TestCase):

     

       26
       26
       +
                    '/opt/homebrew/lib/libgeos_c.dylib',  # homebrew (macOS)

     

       27
       27
       +
                    os.path.join(sys.prefix, "lib", "libgeos_c.so"), # anaconda (Linux)

     

       28
       28
       +
                    'libgeos_c.so.1',

     

       29
       29
       +
       -            'libgeos_c.so'])

     

       30
       30
       +
       +            'libgeos_c.so',

     

       31
       31
       +
       +            '@libgeos_c@'])

+66

pkgs/by-name/ki/kikit/solidpython/default.nix

···

       1
       1
       +
       # SolidPython is an unmaintained library with old dependencies.

     

       2
       2
       +
       { buildPythonPackage

     

       3
       3
       +
       , callPackage

     

       4
       4
       +
       , fetchFromGitHub

     

       5
       5
       +
       , fetchFromGitLab

     

       6
       6
       +
       , fetchpatch

     

       7
       7
       +
       , lib

     

       8
       8
       +
       , pythonRelaxDepsHook

     

       9
       9
       +
       

     

       10
       10
       +
       , poetry-core

     

       11
       11
       +
       , prettytable

     

       12
       12
       +
       , pypng

     

       13
       13
       +
       , ply

     

       14
       14
       +
       , setuptools

     

       15
       15
       +
       , euclid3

     

       16
       16
       +
       }:

     

       17
       17
       +
       buildPythonPackage rec {

     

       18
       18
       +
         pname = "solidpython";

     

       19
       19
       +
         version = "1.1.3";

     

       20
       20
       +
         format = "pyproject";

     

       21
       21
       +
       

     

       22
       22
       +
         src = fetchFromGitHub {

     

       23
       23
       +
           owner = "SolidCode";

     

       24
       24
       +
           repo = "SolidPython";

     

       25
       25
       +
           rev = "d962740d600c5dfd69458c4559fc416b9beab575";

     

       26
       26
       +
           hash = "sha256-3fJta2a5c8hV9FPwKn5pj01aBtsCGSRCz3vvxR/5n0Q=";

     

       27
       27
       +
         };

     

       28
       28
       +
       

     

       29
       29
       +
         nativeBuildInputs = [

     

       30
       30
       +
           poetry-core

     

       31
       31
       +
           pythonRelaxDepsHook

     

       32
       32
       +
         ];

     

       33
       33
       +
       

     

       34
       34
       +
         propagatedBuildInputs = [

     

       35
       35
       +
           ply

     

       36
       36
       +
           setuptools

     

       37
       37
       +
           euclid3

     

       38
       38
       +
       

     

       39
       39
       +
           prettytable

     

       40
       40
       +
         ];

     

       41
       41
       +
       

     

       42
       42
       +
         pythonRelaxDeps = [

     

       43
       43
       +
           # SolidPython has PrettyTable pinned to a hyper-specific version due to

     

       44
       44
       +
           # some ancient bug with Poetry. They aren't interested in unpinning because

     

       45
       45
       +
           # SolidPython v1 seems to be deprecated in favor of v2:

     

       46
       46
       +
           # https://github.com/SolidCode/SolidPython/issues/207

     

       47
       47
       +
           "PrettyTable"

     

       48
       48
       +
         ];

     

       49
       49
       +
       

     

       50
       50
       +
         pythonRemoveDeps = [

     

       51
       51
       +
           # The pypng dependency is only used in an example script.

     

       52
       52
       +
           "pypng"

     

       53
       53
       +
         ];

     

       54
       54
       +
       

     

       55
       55
       +
         pythonImportsCheck = [

     

       56
       56
       +
           "solid"

     

       57
       57
       +
         ];

     

       58
       58
       +
       

     

       59
       59
       +
         meta = with lib; {

     

       60
       60
       +
           description = "Python interface to the OpenSCAD declarative geometry language";

     

       61
       61
       +
           homepage = "https://github.com/SolidCode/SolidPython";

     

       62
       62
       +
           changelog = "https://github.com/SolidCode/SolidPython/releases/tag/v${version}";

     

       63
       63
       +
           maintainers = with maintainers; [ jfly ];

     

       64
       64
       +
           license = licenses.lgpl21Plus;

     

       65
       65
       +
         };

     

       66
       66
       +
       }

+32

pkgs/by-name/lc/lcab/package.nix

···

       1
       1
       +
       { lib

     

       2
       2
       +
       , stdenv

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       }:

     

       5
       5
       +
       

     

       6
       6
       +
       stdenv.mkDerivation (finalAttrs: {

     

       7
       7
       +
         pname = "lcab";

     

       8
       8
       +
         version = "1.0b12";

     

       9
       9
       +
       

     

       10
       10
       +
         src = fetchurl {

     

       11
       11
       +
           # Original site is no longer available

     

       12
       12
       +
           url = "http://deb.debian.org/debian/pool/main/l/lcab/lcab_${finalAttrs.version}.orig.tar.gz";

     

       13
       13
       +
           hash = "sha256-Bl8sF5O2XyhHHA9xt88SCnBk8o0cRLB8q/SewOl/H8g=";

     

       14
       14
       +
         };

     

       15
       15
       +
       

     

       16
       16
       +
         patches = [

     

       17
       17
       +
           # Fix version number

     

       18
       18
       +
           (fetchurl {

     

       19
       19
       +
             url = "https://salsa.debian.org/debian/lcab/-/raw/f72d6db6504123bd124b1a4be21ead8cc1535c9e/debian/patches/20-version.patch";

     

       20
       20
       +
             hash = "sha256-Yb6E8nQVdicmjcGnxR7HHdsd7D+ThXk02UHiaB+PLvE=";

     

       21
       21
       +
           })

     

       22
       22
       +
         ];

     

       23
       23
       +
       

     

       24
       24
       +
         meta = with lib; {

     

       25
       25
       +
           description = "Create cabinet (.cab) archives";

     

       26
       26
       +
           homepage = "http://ohnopub.net/~ohnobinki/lcab";

     

       27
       27
       +
           license = licenses.gpl2Only;

     

       28
       28
       +
           maintainers = with maintainers; [ emilytrau ];

     

       29
       29
       +
           platforms = platforms.unix;

     

       30
       30
       +
           mainProgram = "lcab";

     

       31
       31
       +
         };

     

       32
       32
       +
       })

+101 -77

pkgs/by-name/sy/symbolicator/Cargo.lock

···

       222
       222
        
        "hex",

     

       223
       223
        
        "http",

     

       224
       224
        
        "hyper",

     

       225
       225
       -
        "ring",

     

       225
       225
       +
        "ring 0.16.20",

     

       226
       226
        
        "time",

     

       227
       227
        
        "tokio",

     

       228
       228
        
        "tower",

     
···

       287
       287
        
       

     

       288
       288
        
       [[package]]

     

       289
       289
        
       name = "aws-sdk-s3"

     

       290
       290
       -
       version = "0.31.2"

     

       290
       290
       +
       version = "0.33.0"

     

       291
       291
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       292
       292
       -
       checksum = "c681fef332c3462634cd97fced8d1ac3cfdf790829bd7bfb4006cfba76712053"

     

       292
       292
       +
       checksum = "73018483d9cb78e1a0d4dcbc94327b01d532e7cb28f26c5bceff97f8f0e4c6eb"

     

       293
       293
        
       dependencies = [

     

       294
       294
        
        "aws-credential-types",

     

       295
       295
        
        "aws-http",

     
···

       672
       672
        
        "object",

     

       673
       673
        
        "rustc-demangle",

     

       674
       674
        
       ]

     

       675
       675
       -
       

     

       676
       676
       -
       [[package]]

     

       677
       677
       -
       name = "base64"

     

       678
       678
       -
       version = "0.13.1"

     

       679
       679
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       680
       680
       -
       checksum = "9e1b586273c5702936fe7b7d6896644d8be71e6314cfe09d3167c95f712589e8"

     

       681
       675
        
       

     

       682
       676
        
       [[package]]

     

       683
       677
        
       name = "base64"

     
···

       810
       804
        
       

     

       811
       805
        
       [[package]]

     

       812
       806
        
       name = "bytecount"

     

       813
       813
       -
       version = "0.6.4"

     

       807
       807
       +
       version = "0.6.5"

     

       814
       808
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       815
       815
       -
       checksum = "ad152d03a2c813c80bb94fedbf3a3f02b28f793e39e7c214c8a0bcc196343de7"

     

       809
       809
       +
       checksum = "d1a12477b7237a01c11a80a51278165f9ba0edd28fa6db00a65ab230320dc58c"

     

       816
       810
        
       

     

       817
       811
        
       [[package]]

     

       818
       812
        
       name = "byteorder"

     
···

       1054
       1048
        
       

     

       1055
       1049
        
       [[package]]

     

       1056
       1050
        
       name = "cpufeatures"

     

       1057
       1057
       -
       version = "0.2.9"

     

       1051
       1051
       +
       version = "0.2.10"

     

       1058
       1052
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       1059
       1059
       -
       checksum = "a17b76ff3a4162b0b27f354a0c87015ddad39d35f9c0c36607a3bdd175dde1f1"

     

       1053
       1053
       +
       checksum = "3fbc60abd742b35f2492f808e1abbb83d45f72db402e14c55057edc9c7b1e9e4"

     

       1060
       1054
        
       dependencies = [

     

       1061
       1055
        
        "libc",

     

       1062
       1056
        
       ]

     
···

       1567
       1561
        
       checksum = "7d3b20d3058763d26d88e6e7a49998841e5296735b00dbfb064ff7cb142933dd"

     

       1568
       1562
        
       dependencies = [

     

       1569
       1563
        
        "async-trait",

     

       1570
       1570
       -
        "base64 0.21.4",

     

       1564
       1564
       +
        "base64",

     

       1571
       1565
        
        "dirs-next",

     

       1572
       1566
        
        "hyper",

     

       1573
       1567
        
        "hyper-rustls",

     

       1574
       1574
       -
        "ring",

     

       1568
       1568
       +
        "ring 0.16.20",

     

       1575
       1569
        
        "rustls",

     

       1576
       1570
        
        "rustls-pemfile",

     

       1577
       1571
        
        "serde",

     
···

       1660
       1654
        
       

     

       1661
       1655
        
       [[package]]

     

       1662
       1656
        
       name = "hashbrown"

     

       1663
       1663
       -
       version = "0.14.1"

     

       1657
       1657
       +
       version = "0.14.2"

     

       1664
       1658
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       1665
       1665
       -
       checksum = "7dfda62a12f55daeae5015f81b0baea145391cb4520f86c248fc615d72640d12"

     

       1659
       1659
       +
       checksum = "f93e7192158dbcda357bdec5fb5788eebf8bbac027f3f33e719d29135ae84156"

     

       1666
       1660
        
       

     

       1667
       1661
        
       [[package]]

     

       1668
       1662
        
       name = "heck"

     
···

       1784
       1778
        
        "httpdate",

     

       1785
       1779
        
        "itoa",

     

       1786
       1780
        
        "pin-project-lite",

     

       1787
       1787
       -
        "socket2 0.4.9",

     

       1781
       1781
       +
        "socket2 0.4.10",

     

       1788
       1782
        
        "tokio",

     

       1789
       1783
        
        "tower-service",

     

       1790
       1784
        
        "tracing",

     
···

       1822
       1816
        
       

     

       1823
       1817
        
       [[package]]

     

       1824
       1818
        
       name = "iana-time-zone"

     

       1825
       1825
       -
       version = "0.1.57"

     

       1819
       1819
       +
       version = "0.1.58"

     

       1826
       1820
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       1827
       1827
       -
       checksum = "2fad5b825842d2b38bd206f3e81d6957625fd7f0a361e345c30e01a0ae2dd613"

     

       1821
       1821
       +
       checksum = "8326b86b6cff230b97d0d312a6c40a60726df3332e721f72a1b035f451663b20"

     

       1828
       1822
        
       dependencies = [

     

       1829
       1823
        
        "android_system_properties",

     

       1830
       1824
        
        "core-foundation-sys",

     

       1831
       1825
        
        "iana-time-zone-haiku",

     

       1832
       1826
        
        "js-sys",

     

       1833
       1827
        
        "wasm-bindgen",

     

       1834
       1834
       -
        "windows",

     

       1828
       1828
       +
        "windows-core",

     

       1835
       1829
        
       ]

     

       1836
       1830
        
       

     

       1837
       1831
        
       [[package]]

     
···

       1893
       1887
        
       checksum = "8adf3ddd720272c6ea8bf59463c04e0f93d0bbf7c5439b691bca2987e0270897"

     

       1894
       1888
        
       dependencies = [

     

       1895
       1889
        
        "equivalent",

     

       1896
       1896
       -
        "hashbrown 0.14.1",

     

       1890
       1890
       +
        "hashbrown 0.14.2",

     

       1897
       1891
        
       ]

     

       1898
       1892
        
       

     

       1899
       1893
        
       [[package]]

     
···

       1936
       1930
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       1937
       1931
        
       checksum = "b58db92f96b720de98181bbbe63c831e87005ab460c1bf306eb2622b4707997f"

     

       1938
       1932
        
       dependencies = [

     

       1939
       1939
       -
        "socket2 0.5.4",

     

       1933
       1933
       +
        "socket2 0.5.5",

     

       1940
       1934
        
        "widestring",

     

       1941
       1935
        
        "windows-sys 0.48.0",

     

       1942
       1936
        
        "winreg",

     
···

       1944
       1938
        
       

     

       1945
       1939
        
       [[package]]

     

       1946
       1940
        
       name = "ipnet"

     

       1947
       1947
       -
       version = "2.8.0"

     

       1941
       1941
       +
       version = "2.9.0"

     

       1948
       1942
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       1949
       1949
       -
       checksum = "28b29a3cd74f0f4598934efe3aeba42bae0eb4680554128851ebbecb02af14e6"

     

       1943
       1943
       +
       checksum = "8f518f335dce6725a761382244631d86cf0ccb2863413590b31338feb467f9c3"

     

       1950
       1944
        
       

     

       1951
       1945
        
       [[package]]

     

       1952
       1946
        
       name = "ipnetwork"

     
···

       2057
       2051
        
       

     

       2058
       2052
        
       [[package]]

     

       2059
       2053
        
       name = "jsonwebtoken"

     

       2060
       2060
       -
       version = "8.3.0"

     

       2054
       2054
       +
       version = "9.1.0"

     

       2061
       2055
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       2062
       2062
       -
       checksum = "6971da4d9c3aa03c3d8f3ff0f4155b534aad021292003895a469716b2a230378"

     

       2056
       2056
       +
       checksum = "155c4d7e39ad04c172c5e3a99c434ea3b4a7ba7960b38ecd562b270b097cce09"

     

       2063
       2057
        
       dependencies = [

     

       2064
       2064
       -
        "base64 0.21.4",

     

       2058
       2058
       +
        "base64",

     

       2065
       2059
        
        "pem",

     

       2066
       2066
       -
        "ring",

     

       2060
       2060
       +
        "ring 0.17.5",

     

       2067
       2061
        
        "serde",

     

       2068
       2062
        
        "serde_json",

     

       2069
       2063
        
        "simple_asn1",

     
···

       2190
       2184
        
       

     

       2191
       2185
        
       [[package]]

     

       2192
       2186
        
       name = "lock_api"

     

       2193
       2193
       -
       version = "0.4.10"

     

       2187
       2187
       +
       version = "0.4.11"

     

       2194
       2188
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       2195
       2195
       -
       checksum = "c1cc9717a20b1bb222f333e6a92fd32f7d8a18ddc5a3191a11af45dcbf4dcd16"

     

       2189
       2189
       +
       checksum = "3c168f8615b12bc01f9c17e2eb0cc07dcae1940121185446edc3744920e8ef45"

     

       2196
       2190
        
       dependencies = [

     

       2197
       2191
        
        "autocfg",

     

       2198
       2192
        
        "scopeguard",

     
···

       2707
       2701
        
       checksum = "3742b2c103b9f06bc9fff0a37ff4912935851bee6d36f3c02bcc755bcfec228f"

     

       2708
       2702
        
       dependencies = [

     

       2709
       2703
        
        "lock_api",

     

       2710
       2710
       -
        "parking_lot_core 0.9.8",

     

       2704
       2704
       +
        "parking_lot_core 0.9.9",

     

       2711
       2705
        
       ]

     

       2712
       2706
        
       

     

       2713
       2707
        
       [[package]]

     
···

       2726
       2720
        
       

     

       2727
       2721
        
       [[package]]

     

       2728
       2722
        
       name = "parking_lot_core"

     

       2729
       2729
       -
       version = "0.9.8"

     

       2723
       2723
       +
       version = "0.9.9"

     

       2730
       2724
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       2731
       2731
       -
       checksum = "93f00c865fe7cabf650081affecd3871070f26767e7b2070a3ffae14c654b447"

     

       2725
       2725
       +
       checksum = "4c42a9226546d68acdd9c0a280d17ce19bfe27a46bf68784e4066115788d008e"

     

       2732
       2726
        
       dependencies = [

     

       2733
       2727
        
        "cfg-if",

     

       2734
       2728
        
        "libc",

     

       2735
       2735
       -
        "redox_syscall 0.3.5",

     

       2729
       2729
       +
        "redox_syscall 0.4.1",

     

       2736
       2730
        
        "smallvec",

     

       2737
       2731
        
        "windows-targets 0.48.5",

     

       2738
       2732
        
       ]

     
···

       2770
       2764
        
       

     

       2771
       2765
        
       [[package]]

     

       2772
       2766
        
       name = "pem"

     

       2773
       2773
       -
       version = "1.1.1"

     

       2767
       2767
       +
       version = "3.0.2"

     

       2774
       2768
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       2775
       2775
       -
       checksum = "a8835c273a76a90455d7344889b0964598e3316e2a79ede8e36f16bdcf2228b8"

     

       2769
       2769
       +
       checksum = "3163d2912b7c3b52d651a055f2c7eec9ba5cd22d26ef75b8dd3a59980b185923"

     

       2776
       2770
        
       dependencies = [

     

       2777
       2777
       -
        "base64 0.13.1",

     

       2771
       2771
       +
        "base64",

     

       2772
       2772
       +
        "serde",

     

       2778
       2773
        
       ]

     

       2779
       2774
        
       

     

       2780
       2775
        
       [[package]]

     
···

       2955
       2950
        
       

     

       2956
       2951
        
       [[package]]

     

       2957
       2952
        
       name = "process-event"

     

       2958
       2958
       -
       version = "23.10.1"

     

       2953
       2953
       +
       version = "23.11.0"

     

       2959
       2954
        
       dependencies = [

     

       2960
       2955
        
        "anyhow",

     

       2961
       2956
        
        "clap",

     
···

       3114
       3109
        
       ]

     

       3115
       3110
        
       

     

       3116
       3111
        
       [[package]]

     

       3112
       3112
       +
       name = "redox_syscall"

     

       3113
       3113
       +
       version = "0.4.1"

     

       3114
       3114
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       3115
       3115
       +
       checksum = "4722d768eff46b75989dd134e5c353f0d6296e5aaa3132e776cbdb56be7731aa"

     

       3116
       3116
       +
       dependencies = [

     

       3117
       3117
       +
        "bitflags 1.3.2",

     

       3118
       3118
       +
       ]

     

       3119
       3119
       +
       

     

       3120
       3120
       +
       [[package]]

     

       3117
       3121
        
       name = "redox_users"

     

       3118
       3122
        
       version = "0.4.3"

     

       3119
       3123
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     
···

       3174
       3178
        
       source = "git+https://github.com/getsentry/reqwest?branch=restricted-connector#04ea4c720aca814c3f1de500b3e6fe3b0feeae4c"

     

       3175
       3179
        
       dependencies = [

     

       3176
       3180
        
        "async-compression",

     

       3177
       3177
       -
        "base64 0.21.4",

     

       3181
       3181
       +
        "base64",

     

       3178
       3182
        
        "bytes",

     

       3179
       3183
        
        "encoding_rs",

     

       3180
       3184
        
        "futures-core",

     
···

       3229
       3233
        
        "libc",

     

       3230
       3234
        
        "once_cell",

     

       3231
       3235
        
        "spin 0.5.2",

     

       3232
       3232
       -
        "untrusted",

     

       3236
       3236
       +
        "untrusted 0.7.1",

     

       3233
       3237
        
        "web-sys",

     

       3234
       3238
        
        "winapi",

     

       3235
       3239
        
       ]

     

       3236
       3240
        
       

     

       3237
       3241
        
       [[package]]

     

       3242
       3242
       +
       name = "ring"

     

       3243
       3243
       +
       version = "0.17.5"

     

       3244
       3244
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       3245
       3245
       +
       checksum = "fb0205304757e5d899b9c2e448b867ffd03ae7f988002e47cd24954391394d0b"

     

       3246
       3246
       +
       dependencies = [

     

       3247
       3247
       +
        "cc",

     

       3248
       3248
       +
        "getrandom",

     

       3249
       3249
       +
        "libc",

     

       3250
       3250
       +
        "spin 0.9.8",

     

       3251
       3251
       +
        "untrusted 0.9.0",

     

       3252
       3252
       +
        "windows-sys 0.48.0",

     

       3253
       3253
       +
       ]

     

       3254
       3254
       +
       

     

       3255
       3255
       +
       [[package]]

     

       3238
       3256
        
       name = "rustc-demangle"

     

       3239
       3257
        
       version = "0.1.23"

     

       3240
       3258
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     
···

       3266
       3284
        
       

     

       3267
       3285
        
       [[package]]

     

       3268
       3286
        
       name = "rustix"

     

       3269
       3269
       -
       version = "0.38.19"

     

       3287
       3287
       +
       version = "0.38.20"

     

       3270
       3288
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       3271
       3271
       -
       checksum = "745ecfa778e66b2b63c88a61cb36e0eea109e803b0b86bf9879fbc77c70e86ed"

     

       3289
       3289
       +
       checksum = "67ce50cb2e16c2903e30d1cbccfd8387a74b9d4c938b6a4c5ec6cc7556f7a8a0"

     

       3272
       3290
        
       dependencies = [

     

       3273
       3291
        
        "bitflags 2.4.1",

     

       3274
       3292
        
        "errno",

     
···

       3284
       3302
        
       checksum = "cd8d6c9f025a446bc4d18ad9632e69aec8f287aa84499ee335599fabd20c3fd8"

     

       3285
       3303
        
       dependencies = [

     

       3286
       3304
        
        "log",

     

       3287
       3287
       -
        "ring",

     

       3305
       3305
       +
        "ring 0.16.20",

     

       3288
       3306
        
        "rustls-webpki",

     

       3289
       3307
        
        "sct",

     

       3290
       3308
        
       ]

     
···

       3307
       3325
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       3308
       3326
        
       checksum = "2d3987094b1d07b653b7dfdc3f70ce9a1da9c51ac18c1b06b662e4f9a0e9f4b2"

     

       3309
       3327
        
       dependencies = [

     

       3310
       3310
       -
        "base64 0.21.4",

     

       3328
       3328
       +
        "base64",

     

       3311
       3329
        
       ]

     

       3312
       3330
        
       

     

       3313
       3331
        
       [[package]]

     
···

       3316
       3334
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       3317
       3335
        
       checksum = "3c7d5dece342910d9ba34d259310cae3e0154b873b35408b787b59bce53d34fe"

     

       3318
       3336
        
       dependencies = [

     

       3319
       3319
       -
        "ring",

     

       3320
       3320
       -
        "untrusted",

     

       3337
       3337
       +
        "ring 0.16.20",

     

       3338
       3338
       +
        "untrusted 0.7.1",

     

       3321
       3339
        
       ]

     

       3322
       3340
        
       

     

       3323
       3341
        
       [[package]]

     
···

       3388
       3406
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       3389
       3407
        
       checksum = "d53dcdb7c9f8158937a7981b48accfd39a43af418591a5d008c7b22b5e1b7ca4"

     

       3390
       3408
        
       dependencies = [

     

       3391
       3391
       -
        "ring",

     

       3392
       3392
       -
        "untrusted",

     

       3409
       3409
       +
        "ring 0.16.20",

     

       3410
       3410
       +
        "untrusted 0.7.1",

     

       3393
       3411
        
       ]

     

       3394
       3412
        
       

     

       3395
       3413
        
       [[package]]

     
···

       3795
       3813
        
       

     

       3796
       3814
        
       [[package]]

     

       3797
       3815
        
       name = "socket2"

     

       3798
       3798
       -
       version = "0.4.9"

     

       3816
       3816
       +
       version = "0.4.10"

     

       3799
       3817
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       3800
       3800
       -
       checksum = "64a4a911eed85daf18834cfaa86a79b7d266ff93ff5ba14005426219480ed662"

     

       3818
       3818
       +
       checksum = "9f7916fc008ca5542385b89a3d3ce689953c143e9304a9bf8beec1de48994c0d"

     

       3801
       3819
        
       dependencies = [

     

       3802
       3820
        
        "libc",

     

       3803
       3821
        
        "winapi",

     
···

       3805
       3823
        
       

     

       3806
       3824
        
       [[package]]

     

       3807
       3825
        
       name = "socket2"

     

       3808
       3808
       -
       version = "0.5.4"

     

       3826
       3826
       +
       version = "0.5.5"

     

       3809
       3827
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       3810
       3810
       -
       checksum = "4031e820eb552adee9295814c0ced9e5cf38ddf1e8b7d566d6de8e2538ea989e"

     

       3828
       3828
       +
       checksum = "7b5fac59a5cb5dd637972e5fca70daf0523c9067fcdc4842f053dae04a18f8e9"

     

       3811
       3829
        
       dependencies = [

     

       3812
       3830
        
        "libc",

     

       3813
       3831
        
        "windows-sys 0.48.0",

     
···

       4200
       4218
        
       

     

       4201
       4219
        
       [[package]]

     

       4202
       4220
        
       name = "symbolicator"

     

       4203
       4203
       -
       version = "23.10.1"

     

       4221
       4221
       +
       version = "23.11.0"

     

       4204
       4222
        
       dependencies = [

     

       4205
       4223
        
        "anyhow",

     

       4206
       4224
        
        "axum",

     
···

       4238
       4256
        
       

     

       4239
       4257
        
       [[package]]

     

       4240
       4258
        
       name = "symbolicator-crash"

     

       4241
       4241
       -
       version = "23.10.1"

     

       4259
       4259
       +
       version = "23.11.0"

     

       4242
       4260
        
       dependencies = [

     

       4243
       4261
        
        "bindgen",

     

       4244
       4262
        
        "cmake",

     
···

       4246
       4264
        
       

     

       4247
       4265
        
       [[package]]

     

       4248
       4266
        
       name = "symbolicator-js"

     

       4249
       4249
       -
       version = "23.10.1"

     

       4267
       4267
       +
       version = "23.11.0"

     

       4250
       4268
        
       dependencies = [

     

       4251
       4269
        
        "data-url",

     

       4252
       4270
        
        "futures",

     
···

       4272
       4290
        
       

     

       4273
       4291
        
       [[package]]

     

       4274
       4292
        
       name = "symbolicator-native"

     

       4275
       4275
       -
       version = "23.10.1"

     

       4293
       4293
       +
       version = "23.11.0"

     

       4276
       4294
        
       dependencies = [

     

       4277
       4295
        
        "anyhow",

     

       4278
       4296
        
        "apple-crash-report-parser",

     
···

       4303
       4321
        
       

     

       4304
       4322
        
       [[package]]

     

       4305
       4323
        
       name = "symbolicator-service"

     

       4306
       4306
       -
       version = "23.10.1"

     

       4324
       4324
       +
       version = "23.11.0"

     

       4307
       4325
        
       dependencies = [

     

       4308
       4326
        
        "anyhow",

     

       4309
       4327
        
        "aws-config",

     
···

       4347
       4365
        
       

     

       4348
       4366
        
       [[package]]

     

       4349
       4367
        
       name = "symbolicator-sources"

     

       4350
       4350
       -
       version = "23.10.1"

     

       4368
       4368
       +
       version = "23.11.0"

     

       4351
       4369
        
       dependencies = [

     

       4352
       4370
        
        "anyhow",

     

       4353
       4371
        
        "aws-types",

     
···

       4362
       4380
        
       

     

       4363
       4381
        
       [[package]]

     

       4364
       4382
        
       name = "symbolicator-stress"

     

       4365
       4365
       -
       version = "23.10.1"

     

       4383
       4383
       +
       version = "23.11.0"

     

       4366
       4384
        
       dependencies = [

     

       4367
       4385
        
        "anyhow",

     

       4368
       4386
        
        "axum",

     
···

       4384
       4402
        
       

     

       4385
       4403
        
       [[package]]

     

       4386
       4404
        
       name = "symbolicator-test"

     

       4387
       4387
       -
       version = "23.10.1"

     

       4405
       4405
       +
       version = "23.11.0"

     

       4388
       4406
        
       dependencies = [

     

       4389
       4407
        
        "axum",

     

       4390
       4408
        
        "humantime",

     
···

       4402
       4420
        
       

     

       4403
       4421
        
       [[package]]

     

       4404
       4422
        
       name = "symbolicli"

     

       4405
       4405
       -
       version = "23.10.1"

     

       4423
       4423
       +
       version = "23.11.0"

     

       4406
       4424
        
       dependencies = [

     

       4407
       4425
        
        "anyhow",

     

       4408
       4426
        
        "clap",

     
···

       4427
       4445
        
       

     

       4428
       4446
        
       [[package]]

     

       4429
       4447
        
       name = "symsorter"

     

       4430
       4430
       -
       version = "23.10.1"

     

       4448
       4448
       +
       version = "23.11.0"

     

       4431
       4449
        
       dependencies = [

     

       4432
       4450
        
        "anyhow",

     

       4433
       4451
        
        "chrono",

     
···

       4525
       4543
        
       

     

       4526
       4544
        
       [[package]]

     

       4527
       4545
        
       name = "thiserror"

     

       4528
       4528
       -
       version = "1.0.49"

     

       4546
       4546
       +
       version = "1.0.50"

     

       4529
       4547
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       4530
       4530
       -
       checksum = "1177e8c6d7ede7afde3585fd2513e611227efd6481bd78d2e82ba1ce16557ed4"

     

       4548
       4548
       +
       checksum = "f9a7210f5c9a7156bb50aa36aed4c95afb51df0df00713949448cf9e97d382d2"

     

       4531
       4549
        
       dependencies = [

     

       4532
       4550
        
        "thiserror-impl",

     

       4533
       4551
        
       ]

     

       4534
       4552
        
       

     

       4535
       4553
        
       [[package]]

     

       4536
       4554
        
       name = "thiserror-impl"

     

       4537
       4537
       -
       version = "1.0.49"

     

       4555
       4555
       +
       version = "1.0.50"

     

       4538
       4556
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       4539
       4539
       -
       checksum = "10712f02019e9288794769fba95cd6847df9874d49d871d062172f9dd41bc4cc"

     

       4557
       4557
       +
       checksum = "266b2e40bc00e5a6c09c3584011e08b06f123c00362c92b975ba9843aaaa14b8"

     

       4540
       4558
        
       dependencies = [

     

       4541
       4559
        
        "proc-macro2",

     

       4542
       4560
        
        "quote",

     
···

       4611
       4629
        
        "mio 0.8.8",

     

       4612
       4630
        
        "num_cpus",

     

       4613
       4631
        
        "pin-project-lite",

     

       4614
       4614
       -
        "socket2 0.5.4",

     

       4632
       4632
       +
        "socket2 0.5.5",

     

       4615
       4633
        
        "tokio-macros",

     

       4616
       4634
        
        "windows-sys 0.48.0",

     

       4617
       4635
        
       ]

     
···

       4773
       4791
        
       

     

       4774
       4792
        
       [[package]]

     

       4775
       4793
        
       name = "tracing"

     

       4776
       4776
       -
       version = "0.1.39"

     

       4794
       4794
       +
       version = "0.1.40"

     

       4777
       4795
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       4778
       4778
       -
       checksum = "ee2ef2af84856a50c1d430afce2fdded0a4ec7eda868db86409b4543df0797f9"

     

       4796
       4796
       +
       checksum = "c3523ab5a71916ccf420eebdf5521fcef02141234bbc0b8a49f2fdc4544364ef"

     

       4779
       4797
        
       dependencies = [

     

       4780
       4798
        
        "log",

     

       4781
       4799
        
        "pin-project-lite",

     
···

       5006
       5024
        
       checksum = "a156c684c91ea7d62626509bce3cb4e1d9ed5c4d978f7b4352658f96a4c26b4a"

     

       5007
       5025
        
       

     

       5008
       5026
        
       [[package]]

     

       5027
       5027
       +
       name = "untrusted"

     

       5028
       5028
       +
       version = "0.9.0"

     

       5029
       5029
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       5030
       5030
       +
       checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"

     

       5031
       5031
       +
       

     

       5032
       5032
       +
       [[package]]

     

       5009
       5033
        
       name = "ureq"

     

       5010
       5034
        
       version = "2.8.0"

     

       5011
       5035
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       5012
       5036
        
       checksum = "f5ccd538d4a604753ebc2f17cd9946e89b77bf87f6a8e2309667c6f2e87855e3"

     

       5013
       5037
        
       dependencies = [

     

       5014
       5014
       -
        "base64 0.21.4",

     

       5038
       5038
       +
        "base64",

     

       5015
       5039
        
        "log",

     

       5016
       5040
        
        "native-tls",

     

       5017
       5041
        
        "once_cell",

     
···

       5044
       5068
        
       

     

       5045
       5069
        
       [[package]]

     

       5046
       5070
        
       name = "uuid"

     

       5047
       5047
       -
       version = "1.4.1"

     

       5071
       5071
       +
       version = "1.5.0"

     

       5048
       5072
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       5049
       5049
       -
       checksum = "79daa5ed5740825c40b389c5e50312b9c86df53fccd33f281df655642b43869d"

     

       5073
       5073
       +
       checksum = "88ad59a7560b41a70d191093a945f0b87bc1deeda46fb237479708a1d6b6cdfc"

     

       5050
       5074
        
       dependencies = [

     

       5051
       5075
        
        "getrandom",

     

       5052
       5076
        
        "serde",

     
···

       5169
       5193
        
       

     

       5170
       5194
        
       [[package]]

     

       5171
       5195
        
       name = "wasm-split"

     

       5172
       5172
       -
       version = "23.10.1"

     

       5196
       5196
       +
       version = "23.11.0"

     

       5173
       5197
        
       dependencies = [

     

       5174
       5198
        
        "anyhow",

     

       5175
       5199
        
        "clap",

     
···

       5297
       5321
        
       checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"

     

       5298
       5322
        
       

     

       5299
       5323
        
       [[package]]

     

       5300
       5300
       -
       name = "windows"

     

       5301
       5301
       -
       version = "0.48.0"

     

       5324
       5324
       +
       name = "windows-core"

     

       5325
       5325
       +
       version = "0.51.1"

     

       5302
       5326
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       5303
       5303
       -
       checksum = "e686886bc078bc1b0b600cac0147aadb815089b6e4da64016cbd754b6342700f"

     

       5327
       5327
       +
       checksum = "f1f8cf84f35d2db49a46868f947758c7a1138116f7fac3bc844f43ade1292e64"

     

       5304
       5328
        
       dependencies = [

     

       5305
       5329
        
        "windows-targets 0.48.5",

     

       5306
       5330
        
       ]

+2 -2

pkgs/by-name/sy/symbolicator/package.nix

···

       11
       11
        
       

     

       12
       12
        
       rustPlatform.buildRustPackage rec {

     

       13
       13
        
         pname = "symbolicator";

     

       14
       14
       -
         version = "23.10.1";

     

       14
       14
       +
         version = "23.11.0";

     

       15
       15
        
       

     

       16
       16
        
         src = fetchFromGitHub {

     

       17
       17
        
           owner = "getsentry";

     

       18
       18
        
           repo = "symbolicator";

     

       19
       19
        
           rev = version;

     

       20
       20
       -
           hash = "sha256-G8ElLH6u07uJR2Jz05rM59tnVADaDQ768lK477NuWuM=";

     

       20
       20
       +
           hash = "sha256-eXMMk12ZxRs5k3DaRhGADwLbE62L8e4N3R5Rw8kZMKI=";

     

       21
       21
        
           fetchSubmodules = true;

     

       22
       22
        
         };

     

       23
       23

+2 -2

pkgs/data/fonts/sil-abyssinica/default.nix

···

       2
       2
        
       

     

       3
       3
        
       stdenvNoCC.mkDerivation rec {

     

       4
       4
        
         pname = "sil-abyssinica";

     

       5
       5
       -
         version = "2.200";

     

       5
       5
       +
         version = "2.201";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchzip {

     

       8
       8
        
           url = "https://software.sil.org/downloads/r/abyssinica/AbyssinicaSIL-${version}.zip";

     

       9
       9
       -
           hash = "sha256-IdWMZHm9VoLVDO0//ISujxlXUxe0O6+aEcdP63YRmPg=";

     

       9
       9
       +
           hash = "sha256-DJWp3T9uBLnztSq9r5YCSWaBjIK/0Aljg1IiU0FLrdE=";

     

       10
       10
        
         };

     

       11
       11
        
       

     

       12
       12
        
         installPhase = ''

+4 -3

pkgs/development/interpreters/babashka/default.nix

···

       33
       33
        
           doInstallCheck = true;

     

       34
       34
        
       

     

       35
       35
        
           installCheckPhase = ''

     

       36
       36
       -
             $out/bin/bb --version | grep '${version}'

     

       37
       37
       -
             $out/bin/bb '(+ 1 2)' | grep '3'

     

       38
       38
       -
             $out/bin/bb '(vec (dedupe *input*))' <<< '[1 1 1 1 2]' | grep '[1 2]'

     

       36
       36
       +
             $out/bin/bb --version | fgrep '${version}'

     

       37
       37
       +
             $out/bin/bb '(+ 1 2)' | fgrep '3'

     

       38
       38
       +
             $out/bin/bb '(vec (dedupe *input*))' <<< '[1 1 1 1 2]' | fgrep '[1 2]'

     

       39
       39
       +
             $out/bin/bb '(prn "bépo àê")' | fgrep 'bépo àê'

     

       39
       40
        
           '';

     

       40
       41
        
       

     

       41
       42
        
           # As of v1.2.174, this will remove references to ${graalvmDrv}/conf/chronology,

+2 -2

pkgs/development/libraries/vulkan-utility-libraries/default.nix

···

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation (finalAttrs: {

     

       4
       4
        
         pname = "vulkan-utility-libraries";

     

       5
       5
       -
         version = "1.3.269";

     

       5
       5
       +
         version = "1.3.270";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "KhronosGroup";

     

       9
       9
        
           repo = "Vulkan-Utility-Libraries";

     

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

     

       11
       11
       -
           hash = "sha256-7BN+U97dqpSyCYhHuFTPqokRnABH7Gt91njZPxItpzg=";

     

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

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         nativeBuildInputs = [ cmake python3 ];

+4 -2

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

···

       2
       2
        
       

     

       3
       3
        
       buildDunePackage rec {

     

       4
       4
        
         pname = "cry";

     

       5
       5
       -
         version = "0.6.7";

     

       5
       5
       +
         version = "1.0.1";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "savonet";

     

       9
       9
        
           repo = "ocaml-cry";

     

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

     

       11
       11
       -
           sha256 = "sha256-1Omp3LBKGTPVwEBd530H0Djn3xiEjOHLqso6S8yIJSQ=";

     

       11
       11
       +
           sha256 = "sha256-wn9hLqbydzFTdYsJ1e76dmDLtwcZ7CGjbzFe5o9veYQ=";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         postPatch = ''

     

       15
       15
        
           substituteInPlace src/dune --replace bytes ""

     

       16
       16
        
         '';

     

       17
       17
       +
       

     

       18
       18
       +
         minimalOCamlVersion = "4.12";

     

       17
       19
        
       

     

       18
       20
        
         meta = with lib; {

     

       19
       21
        
           homepage = "https://github.com/savonet/ocaml-cry";

+2 -4

pkgs/development/ocaml-modules/ffmpeg/base.nix

···

       1
       1
        
       { lib, fetchFromGitHub }:

     

       2
       2
        
       

     

       3
       3
        
       rec {

     

       4
       4
       -
         version = "1.1.7";

     

       5
       5
       -
       

     

       6
       6
       -
         duneVersion = "3";

     

       4
       4
       +
         version = "1.1.8";

     

       7
       5
        
       

     

       8
       6
        
         src = fetchFromGitHub {

     

       9
       7
        
           owner = "savonet";

     

       10
       8
        
           repo = "ocaml-ffmpeg";

     

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

     

       12
       12
       -
           sha256 = "sha256-0QDy0ZUAtojYIuNliiDV2uywBnWxtKUhZ/LPqkfSOZ4=";

     

       10
       10
       +
           sha256 = "sha256-XqZATaxpW0lEdrRTXVTc0laQAx437+eoa/zOzZV1kHk=";

     

       13
       11
        
         };

     

       14
       12
        
       

     

       15
       13
        
         meta = with lib; {

+1 -1

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

···

       14
       14
        
       

     

       15
       15
        
         minimalOCamlVersion = "4.08";

     

       16
       16
        
       

     

       17
       17
       -
         inherit (ffmpeg-base) version src duneVersion;

     

       17
       17
       +
         inherit (ffmpeg-base) version src;

     

       18
       18
        
       

     

       19
       19
        
         propagatedBuildInputs = [

     

       20
       20
        
           ffmpeg-avutil

+1 -1

pkgs/development/ocaml-modules/ffmpeg/ffmpeg-av.nix

···

       11
       11
        
       

     

       12
       12
        
         minimalOCamlVersion = "4.08";

     

       13
       13
        
       

     

       14
       14
       -
         inherit (ffmpeg-base) version src duneVersion;

     

       14
       14
       +
         inherit (ffmpeg-base) version src;

     

       15
       15
        
       

     

       16
       16
        
         nativeBuildInputs = [ pkg-config ];

     

       17
       17
        
         buildInputs = [ dune-configurator ] ++ lib.optionals stdenv.isDarwin [ AudioToolbox VideoToolbox ];

+1 -1

pkgs/development/ocaml-modules/ffmpeg/ffmpeg-avcodec.nix

···

       11
       11
        
       

     

       12
       12
        
         minimalOCamlVersion = "4.08";

     

       13
       13
        
       

     

       14
       14
       -
         inherit (ffmpeg-base) version src duneVersion;

     

       14
       14
       +
         inherit (ffmpeg-base) version src;

     

       15
       15
        
       

     

       16
       16
        
         nativeBuildInputs = [ pkg-config ];

     

       17
       17
        
         buildInputs = [ dune-configurator ]

+1 -1

pkgs/development/ocaml-modules/ffmpeg/ffmpeg-avdevice.nix

···

       17
       17
        
       

     

       18
       18
        
         minimalOCamlVersion = "4.08";

     

       19
       19
        
       

     

       20
       20
       -
         inherit (ffmpeg-base) version src duneVersion;

     

       20
       20
       +
         inherit (ffmpeg-base) version src;

     

       21
       21
        
       

     

       22
       22
        
         nativeBuildInputs = [ pkg-config ];

     

       23
       23
        
         buildInputs = [ dune-configurator ]

+1 -1

pkgs/development/ocaml-modules/ffmpeg/ffmpeg-avfilter.nix

···

       13
       13
        
       

     

       14
       14
        
         minimalOCamlVersion = "4.08";

     

       15
       15
        
       

     

       16
       16
       -
         inherit (ffmpeg-base) version src duneVersion;

     

       16
       16
       +
         inherit (ffmpeg-base) version src;

     

       17
       17
        
       

     

       18
       18
        
         nativeBuildInputs = [ pkg-config ];

     

       19
       19
        
         buildInputs = [ dune-configurator ]

+1 -1

pkgs/development/ocaml-modules/ffmpeg/ffmpeg-avutil.nix

···

       9
       9
        
       

     

       10
       10
        
         minimalOCamlVersion = "4.08";

     

       11
       11
        
       

     

       12
       12
       -
         inherit (ffmpeg-base) version src duneVersion;

     

       12
       12
       +
         inherit (ffmpeg-base) version src;

     

       13
       13
        
       

     

       14
       14
        
         nativeBuildInputs = [ pkg-config ];

     

       15
       15
        
         buildInputs = [ dune-configurator ] ++ lib.optionals stdenv.isDarwin [ AudioToolbox VideoToolbox ];

+1 -1

pkgs/development/ocaml-modules/ffmpeg/ffmpeg-swresample.nix

···

       10
       10
        
       

     

       11
       11
        
         minimalOCamlVersion = "4.08";

     

       12
       12
        
       

     

       13
       13
       -
         inherit (ffmpeg-base) version src duneVersion;

     

       13
       13
       +
         inherit (ffmpeg-base) version src;

     

       14
       14
        
       

     

       15
       15
        
         nativeBuildInputs = [ pkg-config ];

     

       16
       16
        
         buildInputs = [ dune-configurator ] ++ lib.optionals stdenv.isDarwin [ VideoToolbox ];

+1 -1

pkgs/development/ocaml-modules/ffmpeg/ffmpeg-swscale.nix

···

       10
       10
        
       

     

       11
       11
        
         minimalOCamlVersion = "4.08";

     

       12
       12
        
       

     

       13
       13
       -
         inherit (ffmpeg-base) version src duneVersion;

     

       13
       13
       +
         inherit (ffmpeg-base) version src;

     

       14
       14
        
       

     

       15
       15
        
         nativeBuildInputs = [ pkg-config ];

     

       16
       16
        
         buildInputs = [ dune-configurator ] ++ lib.optionals stdenv.isDarwin [ VideoToolbox ];

+2 -2

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

···

       2
       2
        
       

     

       3
       3
        
       buildDunePackage rec {

     

       4
       4
        
         pname = "flac";

     

       5
       5
       -
         version = "0.3.1";

     

       5
       5
       +
         version = "0.5.0";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "savonet";

     

       9
       9
        
           repo = "ocaml-flac";

     

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

     

       11
       11
       -
           sha256 = "sha256-oMmxZtphEX/OPfyTumjkWQJidAjSRqriygaTjVJTCG0=";

     

       11
       11
       +
           sha256 = "sha256-HRRQd//e6Eh2HuyO+U00ILu5FoBT9jf/nRJzDOie70A=";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         nativeBuildInputs = [ pkg-config ];

+22

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

···

       1
       1
       +
       { lib, buildDunePackage, fetchFromGitHub, dune-configurator, pkg-config, ogg, flac }:

     

       2
       2
       +
       

     

       3
       3
       +
       buildDunePackage rec {

     

       4
       4
       +
         pname = "metadata";

     

       5
       5
       +
         version = "0.2.0";

     

       6
       6
       +
       

     

       7
       7
       +
         src = fetchFromGitHub {

     

       8
       8
       +
           owner = "savonet";

     

       9
       9
       +
           repo = "ocaml-metadata";

     

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

     

       11
       11
       +
           sha256 = "sha256-sSekkyJ8D6mCCmxIyd+pBk/khaehA3BcpUQl2Gln+Ic=";

     

       12
       12
       +
         };

     

       13
       13
       +
       

     

       14
       14
       +
         minimalOCamlVersion = "4.14";

     

       15
       15
       +
       

     

       16
       16
       +
         meta = with lib; {

     

       17
       17
       +
           homepage = "https://github.com/savonet/ocaml-metadata";

     

       18
       18
       +
           description = "Library to read metadata from files in various formats. ";

     

       19
       19
       +
           license = licenses.gpl3Plus;

     

       20
       20
       +
           maintainers = with maintainers; [ dandellion ];

     

       21
       21
       +
         };

     

       22
       22
       +
       }

+2 -2

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

···

       12
       12
        
       

     

       13
       13
        
       buildPythonPackage rec {

     

       14
       14
        
         pname = "accuweather";

     

       15
       15
       -
         version = "2.0.0";

     

       15
       15
       +
         version = "2.1.0";

     

       16
       16
        
         format = "setuptools";

     

       17
       17
        
       

     

       18
       18
        
         disabled = pythonOlder "3.9";

     
···

       21
       21
        
           owner = "bieniu";

     

       22
       22
        
           repo = pname;

     

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

     

       24
       24
       -
           hash = "sha256-elpVclH/sVQHEp3kTiwbDproJcB85F7m5sEjXwSEtNk=";

     

       24
       24
       +
           hash = "sha256-7uCR/xUARUakODeLVdI13D9ZksvN9c63o3Q0MlJp8cs=";

     

       25
       25
        
         };

     

       26
       26
        
       

     

       27
       27
        
         propagatedBuildInputs = [

+2 -2

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

···

       18
       18
        
       

     

       19
       19
        
       buildPythonPackage rec {

     

       20
       20
        
         pname = "asyncua";

     

       21
       21
       -
         version = "1.0.4";

     

       21
       21
       +
         version = "1.0.5";

     

       22
       22
        
         format = "setuptools";

     

       23
       23
        
       

     

       24
       24
        
         disabled = pythonOlder "3.8";

     
···

       27
       27
        
           owner = "FreeOpcUa";

     

       28
       28
        
           repo = "opcua-asyncio";

     

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

     

       30
       30
       -
           hash = "sha256-gAyvo+VJPdS/UpXN/h8LqbIRyx84fifSUsW2GUzLgfo=";

     

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

     

       31
       31
        
           fetchSubmodules = true;

     

       32
       32
        
         };

     

       33
       33

+10

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

···

       44
       44
        
           pytestCheckHook

     

       45
       45
        
         ];

     

       46
       46
        
       

     

       47
       47
       +
         disabledTests = [

     

       48
       48
       +
           # test fails with frequency 1/200

     

       49
       49
       +
           # https://github.com/alandtse/auth_capture_proxy/issues/25

     

       50
       50
       +
           "test_return_timer_countdown_refresh_html"

     

       51
       51
       +
         ];

     

       52
       52
       +
       

     

       53
       53
       +
         pythonImportsCheck = [

     

       54
       54
       +
           "authcaptureproxy"

     

       55
       55
       +
         ];

     

       56
       56
       +
       

     

       47
       57
        
         meta = with lib; {

     

       48
       58
        
           changelog = "https://github.com/alandtse/auth_capture_proxy/releases/tag/v${version}";

     

       49
       59
        
           description = "A proxy to capture authentication information from a webpage";

+6 -8

pkgs/development/python-modules/azure-monitor-ingestion/default.nix

···

       10
       10
        
       

     

       11
       11
        
       buildPythonPackage rec {

     

       12
       12
        
         pname = "azure-monitor-ingestion";

     

       13
       13
       -
         version = "1.0.2";

     

       13
       13
       +
         version = "1.0.3";

     

       14
       14
       +
         pyproject = true;

     

       14
       15
        
       

     

       15
       16
        
         disabled = pythonOlder "3.7";

     

       16
       17
        
       

     

       17
       17
       -
         pyproject = true;

     

       18
       18
       -
       

     

       19
       18
        
         src = fetchPypi {

     

       20
       19
        
           inherit pname version;

     

       21
       21
       -
           extension = "zip";

     

       22
       22
       -
           hash = "sha256-xNpYsD1bMIM0Bxy8KtR4rYy4tzfddtoPnEzHfO44At8=";

     

       20
       20
       +
           hash = "sha256-idAEqP+HaZs/0fzyBaqO8enTTySg88w3TSIUceiYdDs=";

     

       23
       21
        
         };

     

       24
       22
        
       

     

       25
       23
        
         nativeBuildInputs = [

     
···

       40
       38
        
         # requires checkout from mono-repo and a mock account

     

       41
       39
        
         doCheck = false;

     

       42
       40
        
       

     

       43
       43
       -
         meta = {

     

       41
       41
       +
         meta = with lib; {

     

       44
       42
        
           changelog = "https://github.com/Azure/azure-sdk-for-python/blob/azure-monitor-ingestion_${version}/sdk/monitor/azure-monitor-ingestion/CHANGELOG.md";

     

       45
       43
        
           description = "Send custom logs to Azure Monitor using the Logs Ingestion API";

     

       46
       44
        
           homepage = "https://github.com/Azure/azure-sdk-for-python/tree/main/sdk/monitor/azure-monitor-ingestion";

     

       47
       47
       -
           license = lib.licenses.mit;

     

       48
       48
       -
           maintainers = with lib.maintainers; [ dotlambda ];

     

       45
       45
       +
           license = licenses.mit;

     

       46
       46
       +
           maintainers = with maintainers; [ dotlambda ];

     

       49
       47
        
         };

     

       50
       48
        
       }

+2 -2

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

···

       7
       7
        
       

     

       8
       8
        
       buildPythonPackage rec {

     

       9
       9
        
         pname = "bitarray";

     

       10
       10
       -
         version = "2.8.2";

     

       10
       10
       +
         version = "2.8.3";

     

       11
       11
        
         format = "setuptools";

     

       12
       12
        
       

     

       13
       13
        
         disabled = pythonOlder "3.7";

     

       14
       14
        
       

     

       15
       15
        
         src = fetchPypi {

     

       16
       16
        
           inherit pname version;

     

       17
       17
       -
           hash = "sha256-+QsvRLWyM2TV+63iw0ZS4Vsfz+gTxG+CjgCPaKcJFg8=";

     

       17
       17
       +
           hash = "sha256-4VWHsr3xjTLrO6JfX1pRvt0NwGsxEqTFPated1O8ZYg=";

     

       18
       18
        
         };

     

       19
       19
        
       

     

       20
       20
        
         checkPhase = ''

+2 -2

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

···

       6
       6
        
       

     

       7
       7
        
       buildPythonPackage rec {

     

       8
       8
        
         pname = "bitstruct";

     

       9
       9
       -
         version = "8.17.0";

     

       9
       9
       +
         version = "8.19.0";

     

       10
       10
        
         format = "setuptools";

     

       11
       11
        
       

     

       12
       12
        
         disabled = pythonOlder "3.7";

     

       13
       13
        
       

     

       14
       14
        
         src = fetchPypi {

     

       15
       15
        
           inherit pname version;

     

       16
       16
       -
           hash = "sha256-65S0DkIYojqo+QQGuDap5u2D5IuNESzj+WQIRjvRuHQ=";

     

       16
       16
       +
           hash = "sha256-11up3e2FwX6IWiCaAOuOJI7kB2IUny8qeTYMqFdGfaw=";

     

       17
       17
        
         };

     

       18
       18
        
       

     

       19
       19
        
         pythonImportsCheck = [

+2 -2

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

···

       14
       14
        
       

     

       15
       15
        
       buildPythonPackage rec {

     

       16
       16
        
         pname = "canals";

     

       17
       17
       -
         version = "0.9.0";

     

       17
       17
       +
         version = "0.10.0";

     

       18
       18
        
         pyproject = true;

     

       19
       19
        
       

     

       20
       20
        
         disabled = pythonOlder "3.8";

     
···

       23
       23
        
           owner = "deepset-ai";

     

       24
       24
        
           repo = "canals";

     

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

     

       26
       26
       -
           hash = "sha256-5pRrpi1qxkFgGqcw7Nfc5rnOTra27H31DLKCglkPf6s=";

     

       26
       26
       +
           hash = "sha256-zTC9zaY2WQ4Sx/1YeEaw23UH0hoP/ktMwzH8x/rER00=";

     

       27
       27
        
         };

     

       28
       28
        
       

     

       29
       29
        
         nativeBuildInputs = [

+8 -7

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

···

       1
       1
        
       { lib

     

       2
       2
        
       , buildPythonPackage

     

       3
       3
        
       , fetchPypi

     

       4
       4
       -
       , setuptools-scm

     

       4
       4
       +
       , setuptools

     

       5
       5
        
       , argparse-addons

     

       6
       6
        
       , bitstruct

     

       7
       7
        
       , can

     
···

       16
       16
        
       

     

       17
       17
        
       buildPythonPackage rec {

     

       18
       18
        
         pname = "cantools";

     

       19
       19
       -
         version = "38.0.2";

     

       20
       20
       -
         format = "setuptools";

     

       19
       19
       +
         version = "39.3.0";

     

       20
       20
       +
         pyproject = true;

     

       21
       21
        
       

     

       22
       22
       -
         disabled = pythonOlder "3.7";

     

       22
       22
       +
         disabled = pythonOlder "3.8";

     

       23
       23
        
       

     

       24
       24
        
         src = fetchPypi {

     

       25
       25
        
           inherit pname version;

     

       26
       26
       -
           hash = "sha256-k7/m9L1lLzaXY+qRYrAnpi9CSoQA8kI9QRN5GM5oxo4=";

     

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

     

       27
       27
        
         };

     

       28
       28
        
       

     

       29
       29
        
         nativeBuildInputs = [

     

       30
       30
       -
           setuptools-scm

     

       30
       30
       +
           setuptools

     

       31
       31
        
         ];

     

       32
       32
        
       

     

       33
       33
        
         propagatedBuildInputs = [

     
···

       50
       50
        
         ];

     

       51
       51
        
       

     

       52
       52
        
         meta = with lib; {

     

       53
       53
       +
           description = "Tools to work with CAN bus";

     

       53
       54
        
           homepage = "https://github.com/cantools/cantools";

     

       54
       54
       -
           description = "CAN bus tools.";

     

       55
       55
       +
           changelog = "https://github.com/cantools/cantools/releases/tag/${version}";

     

       55
       56
        
           license = licenses.mit;

     

       56
       57
        
           maintainers = with maintainers; [ gray-heron ];

     

       57
       58
        
         };

+2 -2

pkgs/development/python-modules/dvc-data/default.nix

···

       14
       14
        
       

     

       15
       15
        
       buildPythonPackage rec {

     

       16
       16
        
         pname = "dvc-data";

     

       17
       17
       -
         version = "2.21.0";

     

       17
       17
       +
         version = "2.21.2";

     

       18
       18
        
         format = "pyproject";

     

       19
       19
        
       

     

       20
       20
        
         disabled = pythonOlder "3.8";

     
···

       23
       23
        
           owner = "iterative";

     

       24
       24
        
           repo = pname;

     

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

     

       26
       26
       -
           hash = "sha256-q9wVPT8mUZyX0I4GdC6qtsCTFH80HsUrrtR2oAby8VE=";

     

       26
       26
       +
           hash = "sha256-2RLf2HBkb/vwbr9JecQQfO68ifVgcBIwmRQkXGJh0Fs=";

     

       27
       27
        
         };

     

       28
       28
        
       

     

       29
       29
        
         SETUPTOOLS_SCM_PRETEND_VERSION = version;

+2 -2

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

···

       55
       55
        
       

     

       56
       56
        
       buildPythonPackage rec {

     

       57
       57
        
         pname = "dvc";

     

       58
       58
       -
         version = "3.28.0";

     

       58
       58
       +
         version = "3.30.0";

     

       59
       59
        
         format = "pyproject";

     

       60
       60
        
       

     

       61
       61
        
         src = fetchFromGitHub {

     

       62
       62
        
           owner = "iterative";

     

       63
       63
        
           repo = pname;

     

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

     

       65
       65
       -
           hash = "sha256-oCNszhLGNXNGiQtp91wT4GfuNzDhbZrVR55K41Ykhdg=";

     

       65
       65
       +
           hash = "sha256-ZAOuXK1snsDZETnpyyDZT65ZWu47Qxtv7l8Blqg2Qtw=";

     

       66
       66
        
         };

     

       67
       67
        
       

     

       68
       68
        
         pythonRelaxDeps = [

+2 -2

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

···

       14
       14
        
       

     

       15
       15
        
       buildPythonPackage rec {

     

       16
       16
        
         pname = "dvclive";

     

       17
       17
       -
         version = "3.2.0";

     

       17
       17
       +
         version = "3.3.1";

     

       18
       18
        
         format = "pyproject";

     

       19
       19
        
       

     

       20
       20
        
         disabled = pythonOlder "3.8";

     
···

       23
       23
        
           owner = "iterative";

     

       24
       24
        
           repo = pname;

     

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

     

       26
       26
       -
           hash = "sha256-Z1Nxdz4/45uSypufuwDGiCeUwl+izRGIDA2s9F+jT1Q=";

     

       26
       26
       +
           hash = "sha256-esvDCAsGoaB4t4hiTmoQa69Sgg5crqJyiom/iXxpZow=";

     

       27
       27
        
         };

     

       28
       28
        
       

     

       29
       29
        
         SETUPTOOLS_SCM_PRETEND_VERSION = version;

+25

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

···

       1
       1
       +
       { buildPythonPackage

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchPypi

     

       4
       4
       +
       }:

     

       5
       5
       +
       buildPythonPackage rec {

     

       6
       6
       +
         pname = "euclid3";

     

       7
       7
       +
         version = "0.01";

     

       8
       8
       +
         format = "setuptools";

     

       9
       9
       +
       

     

       10
       10
       +
         src = fetchPypi {

     

       11
       11
       +
           inherit pname version;

     

       12
       12
       +
           hash = "sha256-JbgnpXrb/Zo/qGJeQ6vD6Qf2HeYiND5+U4SC75tG/Qs=";

     

       13
       13
       +
         };

     

       14
       14
       +
       

     

       15
       15
       +
         pythonImportsCheck = [

     

       16
       16
       +
           "euclid3"

     

       17
       17
       +
         ];

     

       18
       18
       +
       

     

       19
       19
       +
         meta = with lib; {

     

       20
       20
       +
           description = "2D and 3D vector, matrix, quaternion and geometry module.";

     

       21
       21
       +
           homepage = "http://code.google.com/p/pyeuclid/";

     

       22
       22
       +
           license = licenses.lgpl21Plus;

     

       23
       23
       +
           maintainers = with maintainers; [ jfly matusf ];

     

       24
       24
       +
         };

     

       25
       25
       +
       }

+2 -2

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

···

       12
       12
        
       

     

       13
       13
        
       buildPythonPackage rec {

     

       14
       14
        
         pname = "griffe";

     

       15
       15
       -
         version = "0.36.9";

     

       15
       15
       +
         version = "0.38.0";

     

       16
       16
        
         format = "pyproject";

     

       17
       17
        
       

     

       18
       18
        
         disabled = pythonOlder "3.8";

     
···

       21
       21
        
           owner = "mkdocstrings";

     

       22
       22
        
           repo = pname;

     

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

     

       24
       24
       -
           hash = "sha256-5j6boIy2LnB3Y0ZzheTdflON8KaQkeQS5vkaPIsETGk=";

     

       24
       24
       +
           hash = "sha256-GhohFO5tHb9ByISPUf4U2MrDATE4WjuekcC9QZaP2Ls=";

     

       25
       25
        
         };

     

       26
       26
        
       

     

       27
       27
        
         SETUPTOOLS_SCM_PRETEND_VERSION = version;

+2 -2

pkgs/development/python-modules/gvm-tools/default.nix

···

       10
       10
        
       

     

       11
       11
        
       buildPythonPackage rec {

     

       12
       12
        
         pname = "gvm-tools";

     

       13
       13
       -
         version = "23.10.0";

     

       13
       13
       +
         version = "23.11.0";

     

       14
       14
        
         format = "pyproject";

     

       15
       15
        
       

     

       16
       16
        
         disabled = pythonOlder "3.7";

     
···

       19
       19
        
           owner = "greenbone";

     

       20
       20
        
           repo = pname;

     

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

     

       22
       22
       -
           hash = "sha256-+D9gl2Q1NybL8Na9qDZpDZOBStzJcfE6IUKFwjzr1J0=";

     

       22
       22
       +
           hash = "sha256-ZwImkTYYSscmGJYCpMWmZjToi41XjT4Znpo8j66BKIs=";

     

       23
       23
        
         };

     

       24
       24
        
       

     

       25
       25
        
         nativeBuildInputs = [

+6 -18

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

···

       1
       1
        
       { lib

     

       2
       2
        
       , buildPythonPackage

     

       3
       3
        
       , fetchFromGitHub

     

       4
       4
       -
       , fetchpatch

     

       5
       4
        
       , packaging

     

       6
       5
        
       , poetry-core

     

       7
       6
        
       , pytestCheckHook

     

       8
       7
        
       , pythonOlder

     

       9
       9
       -
       , typing-extensions

     

       10
       8
        
       }:

     

       11
       9
        
       

     

       12
       10
        
       buildPythonPackage rec {

     

       13
       11
        
         pname = "newversion";

     

       14
       14
       -
         version = "1.8.2";

     

       12
       12
       +
         version = "2.0.0";

     

       15
       13
        
         format = "pyproject";

     

       16
       14
        
       

     

       17
       17
       -
         disabled = pythonOlder "3.7";

     

       15
       15
       +
         disabled = pythonOlder "3.8";

     

       18
       16
        
       

     

       19
       17
        
         src = fetchFromGitHub {

     

       20
       18
        
           owner = "vemel";

     

       21
       21
       -
           repo = pname;

     

       22
       22
       -
           rev = version;

     

       23
       23
       -
           hash = "sha256-27HWMzSzyAbiOW7OUhlupRWIVJG6DrpXObXmxlCsmxU=";

     

       19
       19
       +
           repo = "newversion";

     

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

     

       21
       21
       +
           hash = "sha256-v9hfk2/hBkWtOobQdaYXNOZTTcEqnMV6JYqtjjoidOs=";

     

       24
       22
        
         };

     

       25
       23
        
       

     

       26
       26
       -
         patches = [

     

       27
       27
       -
           # https://github.com/vemel/newversion/pull/9

     

       28
       28
       -
           (fetchpatch {

     

       29
       29
       -
             name = "remove-setuptools-dependency.patch";

     

       30
       30
       -
             url = "https://github.com/vemel/newversion/commit/b50562671029dd6834bc7a8ad0dd3f9e0fbdfc1d.patch";

     

       31
       31
       -
             hash = "sha256-6dXVQ9Hk0/EfSwPbW19ZV8MAFcSx+ZRO5G94kbh23GM=";

     

       32
       32
       -
           })

     

       33
       33
       -
         ];

     

       34
       34
       -
       

     

       35
       24
        
         nativeBuildInputs = [

     

       36
       25
        
           poetry-core

     

       37
       26
        
         ];

     

       38
       27
        
       

     

       39
       28
        
         propagatedBuildInputs = [

     

       40
       29
        
           packaging

     

       41
       41
       -
         ] ++ lib.optionals (pythonOlder "3.8") [

     

       42
       42
       -
           typing-extensions

     

       43
       30
        
         ];

     

       44
       31
        
       

     

       45
       32
        
         nativeCheckInputs = [

     
···

       53
       40
        
         meta = with lib; {

     

       54
       41
        
           description = "PEP 440 version manager";

     

       55
       42
        
           homepage = "https://github.com/vemel/newversion";

     

       43
       43
       +
           changelog = "https://github.com/vemel/newversion/releases/tag/${version}";

     

       56
       44
        
           license = with licenses; [ mit ];

     

       57
       45
        
           maintainers = with maintainers; [ fab ];

     

       58
       46
        
         };

+39

pkgs/development/python-modules/pcbnew-transition/default.nix

···

       1
       1
       +
       { pythonOlder

     

       2
       2
       +
       , buildPythonPackage

     

       3
       3
       +
       , fetchPypi

     

       4
       4
       +
       , lib

     

       5
       5
       +
       , kicad

     

       6
       6
       +
       , versioneer

     

       7
       7
       +
       }:

     

       8
       8
       +
       buildPythonPackage rec {

     

       9
       9
       +
         pname = "pcbnewTransition";

     

       10
       10
       +
         version = "0.3.4";

     

       11
       11
       +
         format = "setuptools";

     

       12
       12
       +
       

     

       13
       13
       +
         disabled = pythonOlder "3.7";

     

       14
       14
       +
       

     

       15
       15
       +
         src = fetchPypi {

     

       16
       16
       +
           inherit pname version;

     

       17
       17
       +
           hash = "sha256-3CJUG1kd63Lg0r9HpJRIvttHS5s2EuZRoxeXrqsJ/kQ=";

     

       18
       18
       +
         };

     

       19
       19
       +
       

     

       20
       20
       +
         propagatedBuildInputs = [

     

       21
       21
       +
           kicad

     

       22
       22
       +
         ];

     

       23
       23
       +
       

     

       24
       24
       +
         nativeBuildInputs = [

     

       25
       25
       +
           versioneer

     

       26
       26
       +
         ];

     

       27
       27
       +
       

     

       28
       28
       +
         pythonImportsCheck = [

     

       29
       29
       +
           "pcbnewTransition"

     

       30
       30
       +
         ];

     

       31
       31
       +
       

     

       32
       32
       +
         meta = with lib; {

     

       33
       33
       +
           description = "Library that allows you to support both, KiCad 5, 6 and 7 in your plugins";

     

       34
       34
       +
           homepage = "https://github.com/yaqwsx/pcbnewTransition";

     

       35
       35
       +
           changelog = "https://github.com/yaqwsx/pcbnewTransition/releases/tag/v${version}";

     

       36
       36
       +
           license = licenses.mit;

     

       37
       37
       +
           maintainers = with maintainers; [ jfly matusf ];

     

       38
       38
       +
         };

     

       39
       39
       +
       }

+2 -2

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

···

       10
       10
        
       

     

       11
       11
        
       buildPythonPackage rec {

     

       12
       12
        
         pname = "pegen";

     

       13
       13
       -
         version = "0.2.0";

     

       13
       13
       +
         version = "0.3.0";

     

       14
       14
        
         format = "pyproject";

     

       15
       15
        
       

     

       16
       16
        
         disabled = pythonOlder "3.8";

     
···

       19
       19
        
           owner = "we-like-parsers";

     

       20
       20
        
           repo = pname;

     

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

     

       22
       22
       -
           hash = "sha256-5nxOMgkDAkHtVFSNXf0SPoag6/E7b97eVnFoAqyJE3g=";

     

       22
       22
       +
           hash = "sha256-P4zX8za9lBlXhNPkQe9p136ggZEJh6fHfBr+DQKvtTg=";

     

       23
       23
        
         };

     

       24
       24
        
       

     

       25
       25
        
         SETUPTOOLS_SCM_PRETEND_VERSION = version;

+42

pkgs/development/python-modules/pixel-ring/default.nix

···

       1
       1
       +
       { lib

     

       2
       2
       +
       , buildPythonPackage

     

       3
       3
       +
       , fetchFromGitHub

     

       4
       4
       +
       , setuptools

     

       5
       5
       +
       , wheel

     

       6
       6
       +
       , pyusb

     

       7
       7
       +
       , spidev

     

       8
       8
       +
       }:

     

       9
       9
       +
       

     

       10
       10
       +
       buildPythonPackage rec {

     

       11
       11
       +
         pname = "pixel-ring";

     

       12
       12
       +
         version = "0.1.0";

     

       13
       13
       +
         pyproject = true;

     

       14
       14
       +
       

     

       15
       15
       +
         src = fetchFromGitHub {

     

       16
       16
       +
           owner = "respeaker";

     

       17
       17
       +
           repo = "pixel_ring";

     

       18
       18
       +
           rev = version;

     

       19
       19
       +
           hash = "sha256-J9kScjD6Xon0YWGxFU881bIbjmDpY7cnWzJ8G0SOKaw=";

     

       20
       20
       +
         };

     

       21
       21
       +
       

     

       22
       22
       +
         nativeBuildInputs = [

     

       23
       23
       +
           setuptools

     

       24
       24
       +
           wheel

     

       25
       25
       +
         ];

     

       26
       26
       +
       

     

       27
       27
       +
         propagatedBuildInputs = [

     

       28
       28
       +
           pyusb

     

       29
       29
       +
           spidev

     

       30
       30
       +
         ];

     

       31
       31
       +
       

     

       32
       32
       +
         dontUsePythonImportsCheck = true; # requires SPI access

     

       33
       33
       +
       

     

       34
       34
       +
         doCheck = false; # no tests

     

       35
       35
       +
       

     

       36
       36
       +
         meta = with lib; {

     

       37
       37
       +
           description = "RGB LED library for ReSpeaker 4 Mic Array, ReSpeaker V2 & ReSpeaker USB 6+1 Mic Array";

     

       38
       38
       +
           homepage = "https://github.com/respeaker/pixel_ring/tree/master";

     

       39
       39
       +
           license = licenses.gpl2Only;

     

       40
       40
       +
           maintainers = with maintainers; [ hexa ];

     

       41
       41
       +
         };

     

       42
       42
       +
       }

+38

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

···

       1
       1
       +
       { python3

     

       2
       2
       +
       , fetchPypi

     

       3
       3
       +
       , lib

     

       4
       4
       +
       , pymeta3

     

       5
       5
       +
       , buildPythonPackage

     

       6
       6
       +
       }:

     

       7
       7
       +
       buildPythonPackage rec {

     

       8
       8
       +
         pname = "pybars3";

     

       9
       9
       +
         version = "0.9.7";

     

       10
       10
       +
         format = "setuptools";

     

       11
       11
       +
       

     

       12
       12
       +
         src = fetchPypi {

     

       13
       13
       +
           inherit pname version;

     

       14
       14
       +
           hash = "sha256-ashH6QXlO5xbk2rxEskQR14nv3Z/efRSjBb5rx7A4lI=";

     

       15
       15
       +
         };

     

       16
       16
       +
       

     

       17
       17
       +
         propagatedBuildInputs = [

     

       18
       18
       +
           pymeta3

     

       19
       19
       +
         ];

     

       20
       20
       +
       

     

       21
       21
       +
         checkPhase = ''

     

       22
       22
       +
           runHook preCheck

     

       23
       23
       +
           ${python3.interpreter} tests.py

     

       24
       24
       +
           runHook postCheck

     

       25
       25
       +
         '';

     

       26
       26
       +
       

     

       27
       27
       +
         pythonImportsCheck = [

     

       28
       28
       +
           "pybars"

     

       29
       29
       +
         ];

     

       30
       30
       +
       

     

       31
       31
       +
         meta = with lib; {

     

       32
       32
       +
           description = "Handlebars.js template support for Python 3 and 2";

     

       33
       33
       +
           homepage = "https://github.com/wbond/pybars3";

     

       34
       34
       +
           changelog = "https://github.com/wbond/pybars3/releases/tag/${version}";

     

       35
       35
       +
           license = licenses.lgpl3Only;

     

       36
       36
       +
           maintainers = with maintainers; [ jfly matusf ];

     

       37
       37
       +
         };

     

       38
       38
       +
       }

+29

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

···

       1
       1
       +
       { buildPythonPackage

     

       2
       2
       +
       , fetchPypi

     

       3
       3
       +
       , lib

     

       4
       4
       +
       }:

     

       5
       5
       +
       buildPythonPackage rec {

     

       6
       6
       +
         pname = "pymeta3";

     

       7
       7
       +
         version = "0.5.1";

     

       8
       8
       +
         format = "setuptools";

     

       9
       9
       +
       

     

       10
       10
       +
         src = fetchPypi {

     

       11
       11
       +
           inherit version;

     

       12
       12
       +
           pname = "PyMeta3";

     

       13
       13
       +
           hash = "sha256-GL2jJtmpu/WHv8DuC8loZJZNeLBnKIvPVdTZhoHQW8s=";

     

       14
       14
       +
         };

     

       15
       15
       +
       

     

       16
       16
       +
         doCheck = false; # Tests do not support Python3

     

       17
       17
       +
       

     

       18
       18
       +
         pythonImportsCheck = [

     

       19
       19
       +
           "pymeta"

     

       20
       20
       +
         ];

     

       21
       21
       +
       

     

       22
       22
       +
         meta = with lib; {

     

       23
       23
       +
           description = "Pattern-matching language based on OMeta for Python 3 and 2";

     

       24
       24
       +
           homepage = "https://github.com/wbond/pymeta3";

     

       25
       25
       +
           changelog = "https://github.com/wbond/pymeta3/releases/tag/${version}";

     

       26
       26
       +
           license = licenses.mit;

     

       27
       27
       +
           maintainers = with maintainers; [ jfly matusf ];

     

       28
       28
       +
         };

     

       29
       29
       +
       }

+2 -2

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

···

       16
       16
        
       

     

       17
       17
        
       buildPythonPackage rec {

     

       18
       18
        
         pname = "pyoverkiz";

     

       19
       19
       -
         version = "1.13.1";

     

       19
       19
       +
         version = "1.13.2";

     

       20
       20
        
         format = "pyproject";

     

       21
       21
        
       

     

       22
       22
        
         disabled = pythonOlder "3.7";

     
···

       25
       25
        
           owner = "iMicknl";

     

       26
       26
        
           repo = "python-overkiz-api";

     

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

     

       28
       28
       -
           hash = "sha256-55oqrVjvbdwNn5S3YQVU3saWtFHhoUCcyW9VzXs87YM=";

     

       28
       28
       +
           hash = "sha256-WGFRZhnlTDC9uv9N4sKznIdgjBwpnuT9Gsa8hdlnPAE=";

     

       29
       29
        
         };

     

       30
       30
        
       

     

       31
       31
        
         postPatch = ''

+2 -2

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

···

       13
       13
        
       

     

       14
       14
        
       buildPythonPackage rec {

     

       15
       15
        
         pname = "python-gvm";

     

       16
       16
       -
         version = "23.10.1";

     

       16
       16
       +
         version = "23.11.0";

     

       17
       17
        
         format = "pyproject";

     

       18
       18
        
       

     

       19
       19
        
         disabled = pythonOlder "3.7";

     
···

       22
       22
        
           owner = "greenbone";

     

       23
       23
        
           repo = pname;

     

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

     

       25
       25
       -
           hash = "sha256-OG45mKYqWrgyDyTlWPz95VXQDKAx4QeU1ZZGmHhbviI=";

     

       25
       25
       +
           hash = "sha256-7HneedqHbNB9ZYFUCCQ/puLtA1QlIkTKqji0py9hwBE=";

     

       26
       26
        
         };

     

       27
       27
        
       

     

       28
       28
        
         nativeBuildInputs = [

+2 -2

pkgs/development/python-modules/types-awscrt/default.nix

···

       7
       7
        
       

     

       8
       8
        
       buildPythonPackage rec {

     

       9
       9
        
         pname = "types-awscrt";

     

       10
       10
       -
         version = "0.19.10";

     

       10
       10
       +
         version = "0.19.12";

     

       11
       11
        
         format = "pyproject";

     

       12
       12
        
       

     

       13
       13
        
         disabled = pythonOlder "3.7";

     
···

       15
       15
        
         src = fetchPypi {

     

       16
       16
        
           pname = "types_awscrt";

     

       17
       17
        
           inherit version;

     

       18
       18
       -
           hash = "sha256-YowjnLt7eCBzBfklBOEEDRClp/ToA3KLi+xuftUoti4=";

     

       18
       18
       +
           hash = "sha256-KbJBIVxl622kZPEeIyiTEEky/DxKShyJGSFYv2YEveY=";

     

       19
       19
        
         };

     

       20
       20
        
       

     

       21
       21
        
         nativeBuildInputs = [

+2 -2

pkgs/development/python-modules/weconnect-mqtt/default.nix

···

       10
       10
        
       

     

       11
       11
        
       buildPythonPackage rec {

     

       12
       12
        
         pname = "weconnect-mqtt";

     

       13
       13
       -
         version = "0.48.2";

     

       13
       13
       +
         version = "0.48.3";

     

       14
       14
        
         format = "setuptools";

     

       15
       15
        
       

     

       16
       16
        
         disabled = pythonOlder "3.8";

     
···

       19
       19
        
           owner = "tillsteinbach";

     

       20
       20
        
           repo = "WeConnect-mqtt";

     

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

     

       22
       22
       -
           hash = "sha256-8JJBWF53VOmTD/uetCURFaTkfSTax/YeafKsZtA1xAA=";

     

       22
       22
       +
           hash = "sha256-Pja9BP0gbWXTgOokEngNS364tJp1oWJYNKcTxyYJHGw=";

     

       23
       23
        
         };

     

       24
       24
        
       

     

       25
       25
        
         postPatch = ''

+2 -2

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

···

       12
       12
        
       

     

       13
       13
        
       buildPythonPackage rec {

     

       14
       14
        
         pname = "weconnect";

     

       15
       15
       -
         version = "0.59.4";

     

       15
       15
       +
         version = "0.59.5";

     

       16
       16
        
         format = "setuptools";

     

       17
       17
        
       

     

       18
       18
        
         disabled = pythonOlder "3.8";

     
···

       21
       21
        
           owner = "tillsteinbach";

     

       22
       22
        
           repo = "WeConnect-python";

     

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

     

       24
       24
       -
           hash = "sha256-Z9tiK6oDyyMcXhgUUxSDL9URYDp6Uz8rFPART3qxd+s=";

     

       24
       24
       +
           hash = "sha256-ujIA98QD8ds2/iLLeJqn88nY9tZuuOSnOwGvRznA8PQ=";

     

       25
       25
        
         };

     

       26
       26
        
       

     

       27
       27
        
         propagatedBuildInputs = [

+2 -2

pkgs/development/tools/analysis/checkov/default.nix

···

       5
       5
        
       

     

       6
       6
        
       python3.pkgs.buildPythonApplication rec {

     

       7
       7
        
         pname = "checkov";

     

       8
       8
       -
         version = "3.0.36";

     

       8
       8
       +
         version = "3.0.37";

     

       9
       9
        
         pyproject = true;

     

       10
       10
        
       

     

       11
       11
        
         src = fetchFromGitHub {

     

       12
       12
        
           owner = "bridgecrewio";

     

       13
       13
        
           repo = "checkov";

     

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

     

       15
       15
       -
           hash = "sha256-MrzCqR1+IJAv81fbuaNygGejRF4EzIZWPutL5qLluhU=";

     

       15
       15
       +
           hash = "sha256-cRc5mBMTh5HCqq5hKfvJmYROs74ZiWjX17cgQv7ub+I=";

     

       16
       16
        
         };

     

       17
       17
        
       

     

       18
       18
        
         patches = [

-1

pkgs/development/tools/analysis/rr/default.nix

···

       36
       36
        
         nativeBuildInputs = [ cmake pkg-config which makeWrapper ];

     

       37
       37
        
         buildInputs = [

     

       38
       38
        
           libpfm zlib python3Packages.python python3Packages.pexpect procps gdb capnproto

     

       39
       39
       -
           libpfm zlib python3Packages.python python3Packages.pexpect procps capnproto

     

       40
       39
        
         ];

     

       41
       40
        
         cmakeFlags = [

     

       42
       41
        
           "-Ddisable32bit=ON"

+3 -3

pkgs/development/tools/rust/cargo-codspeed/default.nix

···

       12
       12
        
       

     

       13
       13
        
       rustPlatform.buildRustPackage rec {

     

       14
       14
        
         pname = "cargo-codspeed";

     

       15
       15
       -
         version = "2.3.1";

     

       15
       15
       +
         version = "2.3.2";

     

       16
       16
        
       

     

       17
       17
        
         src = fetchFromGitHub {

     

       18
       18
        
           owner = "CodSpeedHQ";

     

       19
       19
        
           repo = "codspeed-rust";

     

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

     

       21
       21
       -
           hash = "sha256-QEqWSCqX00aMF9kM6xyClJjMiEGmscEWZu0W/MmSj2M=";

     

       21
       21
       +
           hash = "sha256-TjK84A/hoG5TyXbXgr4SPolUBT9tMqz/Mn9pMK6BQE4=";

     

       22
       22
        
         };

     

       23
       23
        
       

     

       24
       24
       -
         cargoHash = "sha256-kZjQFoP5aZyVt0EcMtUUXc1wUZQxUwONMzzN6iLUAbM=";

     

       24
       24
       +
         cargoHash = "sha256-Nfd8YBh+5HlLbxKajptJEH3NFbtBH2V6668c3DHc13g=";

     

       25
       25
        
       

     

       26
       26
        
         nativeBuildInputs = [

     

       27
       27
        
           curl

+2 -2

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

···

       6
       6
        
       }:

     

       7
       7
        
       

     

       8
       8
        
       let

     

       9
       9
       -
         tag = "0.3.4";

     

       9
       9
       +
         tag = "0.3.5";

     

       10
       10
        
       in

     

       11
       11
        
       stdenv.mkDerivation {

     

       12
       12
        
         pname = "apfs";

     
···

       16
       16
        
           owner = "linux-apfs";

     

       17
       17
        
           repo = "linux-apfs-rw";

     

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

     

       19
       19
       -
           hash = "sha256-EeVOrZtmKi5VfPerW9IntjRvdU3AbFPHG+pyAI4ciGk=";

     

       19
       19
       +
           hash = "sha256-rKz9a4Z+tx63rhknQIl/zu/WIMjxxM0+NGyaxnzxLk4=";

     

       20
       20
        
         };

     

       21
       21
        
       

     

       22
       22
        
         hardeningDisable = [ "pic" ];

+40

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

···

       1
       1
       +
       { lib, stdenv, fetchurl, kernel, kmod, mstflint }:

     

       2
       2
       +
       

     

       3
       3
       +
       stdenv.mkDerivation rec {

     

       4
       4
       +
         pname = "mstflint_access";

     

       5
       5
       +
         inherit (mstflint) version;

     

       6
       6
       +
       

     

       7
       7
       +
         src = fetchurl {

     

       8
       8
       +
           url = "https://github.com/Mellanox/mstflint/releases/download/v${version}/kernel-mstflint-${version}.tar.gz";

     

       9
       9
       +
           hash = "sha256-rfZts0m8x6clVazpbAa2xK+dYgRU9Us5rbcWa0uHJ1M=";

     

       10
       10
       +
         };

     

       11
       11
       +
       

     

       12
       12
       +
         nativeBuildInputs = [ kmod ] ++ kernel.moduleBuildDependencies;

     

       13
       13
       +
       

     

       14
       14
       +
         makeFlags = kernel.makeFlags ++ [

     

       15
       15
       +
           "KVER=${kernel.modDirVersion}"

     

       16
       16
       +
           "KSRC=${kernel.dev}/lib/modules/${kernel.modDirVersion}/build"

     

       17
       17
       +
         ];

     

       18
       18
       +
       

     

       19
       19
       +
         enableParallelBuilding = true;

     

       20
       20
       +
       

     

       21
       21
       +
         preConfigure = lib.optionals (lib.versionAtLeast kernel.version "6.4") ''

     

       22
       22
       +
           sed -i "s/class_create(THIS_MODULE, dev->name)/class_create(dev->name)/g" mst_main.c

     

       23
       23
       +
         '';

     

       24
       24
       +
       

     

       25
       25
       +
         installPhase = ''

     

       26
       26
       +
           runHook preInstall

     

       27
       27
       +
       

     

       28
       28
       +
           install -D ${pname}.ko $out/lib/modules/${kernel.modDirVersion}/extra/${pname}.ko

     

       29
       29
       +
       

     

       30
       30
       +
           runHook postInstall

     

       31
       31
       +
         '';

     

       32
       32
       +
       

     

       33
       33
       +
         meta = with lib; {

     

       34
       34
       +
           description = "A kernel module for Nvidia NIC firmware update";

     

       35
       35
       +
           homepage = "https://github.com/Mellanox/mstflint";

     

       36
       36
       +
           license = [ licenses.gpl2Only ];

     

       37
       37
       +
           maintainers = with maintainers; [ thillux ];

     

       38
       38
       +
           platforms = platforms.linux;

     

       39
       39
       +
         };

     

       40
       40
       +
       }

+7 -16

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

···

       1
       1
       -
       { lib, stdenv, fetchFromGitHub, fetchpatch }:

     

       1
       1
       +
       { lib, stdenv, fetchFromGitHub }:

     

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation rec {

     

       4
       4
        
         pname = "trinity";

     

       5
       5
       -
         version = "1.9";

     

       5
       5
       +
         version = "1.9-unstable-2023-07-10";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "kernelslacker";

     

       9
       9
        
           repo = "trinity";

     

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

     

       11
       11
       -
           sha256 = "0z1a7x727xacam74jccd223k303sllgwpq30lnq9b6xxy8b659bv";

     

       10
       10
       +
           rev = "e71872454d26baf37ae1d12e9b04a73d64179555";

     

       11
       11
       +
           hash = "sha256-Zy+4L1CuB2Ul5iF+AokDkAW1wheDzoCTNkvRZFGRNps=";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
       -
         patches = [

     

       15
       15
       -
           # Pull upstream fix for -fno-common toolchains

     

       16
       16
       -
           (fetchpatch {

     

       17
       17
       -
             name = "fno-common.patch";

     

       18
       18
       -
             url = "https://github.com/kernelslacker/trinity/commit/e53e25cc8dd5bdb5f7d9b4247de9e9921eec81d8.patch";

     

       19
       19
       -
             sha256 = "0dbhyc98x11cmac6rj692zymnfqfqcbawlrkg1lhgfagzjxxwshg";

     

       20
       20
       -
           })

     

       21
       21
       -
         ];

     

       22
       22
       -
       

     

       23
       14
        
         postPatch = ''

     

       24
       15
        
           patchShebangs configure

     

       25
       16
        
           patchShebangs scripts

     
···

       27
       18
        
       

     

       28
       19
        
         enableParallelBuilding = true;

     

       29
       20
        
       

     

       30
       30
       -
         makeFlags = [ "DESTDIR=$(out)" ];

     

       21
       21
       +
         installFlags = [ "DESTDIR=$(out)" ];

     

       31
       22
        
       

     

       32
       23
        
         meta = with lib; {

     

       33
       24
        
           description = "A Linux System call fuzz tester";

     

       34
       34
       -
           homepage = "https://codemonkey.org.uk/projects/trinity/";

     

       35
       35
       -
           license = licenses.gpl2;

     

       25
       25
       +
           homepage = "https://github.com/kernelslacker/trinity";

     

       26
       26
       +
           license = licenses.gpl2Only;

     

       36
       27
        
           maintainers = [ maintainers.dezgeg ];

     

       37
       28
        
           platforms = platforms.linux;

     

       38
       29
        
         };

+4

pkgs/servers/http/jetty/11.x.nix

···

       1
       1
       +
       import ./common.nix {

     

       2
       2
       +
         version = "11.0.18";

     

       3
       3
       +
         hash = "sha256-HxtO2r6YWo6+MAYUgk7dNSPDqQZoyO9t/8NdI5pPkL4=";

     

       4
       4
       +
       }

+4

pkgs/servers/http/jetty/12.x.nix

···

       1
       1
       +
       import ./common.nix {

     

       2
       2
       +
         version = "12.0.3";

     

       3
       3
       +
         hash = "sha256-Z/jJKKzoqTPZnoFOMwbpSd/Kd1w+rXloKH+aw6aNrKs=";

     

       4
       4
       +
       }

+8 -4

pkgs/servers/http/jetty/default.nix pkgs/servers/http/jetty/common.nix

···

       1
       1
       +
       { version, hash }:

     

       2
       2
       +
       

     

       1
       3
        
       { lib, stdenv, fetchurl }:

     

       2
       4
        
       

     

       3
       5
        
       stdenv.mkDerivation rec {

     

       4
       6
        
         pname = "jetty";

     

       5
       5
       -
         version = "12.0.2";

     

       7
       7
       +
       

     

       8
       8
       +
         inherit version;

     

       9
       9
       +
       

     

       6
       10
        
         src = fetchurl {

     

       7
       11
        
           url = "mirror://maven/org/eclipse/jetty/jetty-home/${version}/jetty-home-${version}.tar.gz";

     

       8
       8
       -
           hash = "sha256-DtlHTXjbr31RmK6ycDdiWOL7jIpbWNh0la90OnOhzvM=";

     

       12
       12
       +
           inherit hash;

     

       9
       13
        
         };

     

       10
       14
        
       

     

       11
       15
        
         dontBuild = true;

     
···

       17
       21
        
       

     

       18
       22
        
         meta = with lib; {

     

       19
       23
        
           description = "A Web server and javax.servlet container";

     

       20
       20
       -
           homepage = "https://www.eclipse.org/jetty/";

     

       24
       24
       +
           homepage = "https://eclipse.dev/jetty/";

     

       21
       25
        
           platforms = platforms.all;

     

       22
       26
        
           sourceProvenance = with sourceTypes; [ binaryBytecode ];

     

       23
       27
        
           license = with licenses; [ asl20 epl10 ];

     

       24
       24
       -
           maintainers = with maintainers; [ emmanuelrosa ];

     

       28
       28
       +
           maintainers = with maintainers; [ emmanuelrosa anthonyroussel ];

     

       25
       29
        
         };

     

       26
       30
        
       }

+65 -28

pkgs/tools/audio/liquidsoap/full.nix

···

       1
       1
       -
       { lib, stdenv, makeWrapper, fetchurl, which, pkg-config

     

       1
       1
       +
       { lib, stdenv, makeWrapper, fetchFromGitHub, which, pkg-config

     

       2
       2
        
       , libjpeg

     

       3
       3
        
       , ocamlPackages

     

       4
       4
       -
       , awscli2, curl, ffmpeg, youtube-dl

     

       5
       5
       -
       , runtimePackages ? [ awscli2 curl ffmpeg youtube-dl ]

     

       4
       4
       +
       , awscli2, bubblewrap, curl, ffmpeg, yt-dlp

     

       5
       5
       +
       , runtimePackages ? [ awscli2 bubblewrap curl ffmpeg yt-dlp ]

     

       6
       6
        
       }:

     

       7
       7
        
       

     

       8
       8
        
       let

     

       9
       9
        
         pname = "liquidsoap";

     

       10
       10
       -
         version = "2.1.4";

     

       10
       10
       +
         version = "2.2.2";

     

       11
       11
        
       in

     

       12
       12
        
       stdenv.mkDerivation {

     

       13
       13
        
         inherit pname version;

     

       14
       14
        
       

     

       15
       15
       -
         src = fetchurl {

     

       16
       16
       -
           url = "https://github.com/savonet/${pname}/releases/download/v${version}/${pname}-${version}.tar.bz2";

     

       17
       17
       -
           sha256 = "sha256-GQuG7f9U+/HqPcuj6hnBoH5mWEhxSwWgBnkCuLqHTAc=";

     

       15
       15
       +
         src = fetchFromGitHub {

     

       16
       16
       +
           owner = "savonet";

     

       17
       17
       +
           repo = "liquidsoap";

     

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

     

       19
       19
       +
           hash = "sha256-t7rkWHSAd3DaTCXaGfL9NcIQYT+f4Od9D6huuZlwhWk=";

     

       18
       20
        
         };

     

       19
       21
        
       

     

       20
       20
       -
         postFixup = ''

     

       22
       22
       +
         postPatch = ''

     

       23
       23
       +
           substituteInPlace src/lang/dune \

     

       24
       24
       +
             --replace "(run git rev-parse --short HEAD)" "(run echo -n nixpkgs)"

     

       25
       25
       +
         '';

     

       26
       26
       +
       

     

       27
       27
       +
         dontConfigure = true;

     

       28
       28
       +
       

     

       29
       29
       +
         buildPhase = ''

     

       30
       30
       +
           runHook preBuild

     

       31
       31
       +
       

     

       32
       32
       +
           dune build

     

       33
       33
       +
       

     

       34
       34
       +
           runHook postBuild

     

       35
       35
       +
         '';

     

       36
       36
       +
       

     

       37
       37
       +
         installPhase = ''

     

       38
       38
       +
           runHook preInstall

     

       39
       39
       +
       

     

       40
       40
       +
           dune install --prefix "$out"

     

       41
       41
       +
       

     

       42
       42
       +
           runHook postInstall

     

       43
       43
       +
         '';

     

       44
       44
       +
       

     

       45
       45
       +
         fixupPhase = ''

     

       46
       46
       +
           runHook preFixup

     

       47
       47
       +
       

     

       21
       48
        
           wrapProgram $out/bin/liquidsoap \

     

       22
       49
        
             --set LIQ_LADSPA_PATH /run/current-system/sw/lib/ladspa \

     

       23
       50
        
             --prefix PATH : ${lib.makeBinPath runtimePackages}

     

       51
       51
       +
       

     

       52
       52
       +
           runHook postFixup

     

       24
       53
        
         '';

     

       25
       54
        
       

     

       26
       26
       -
       

     

       27
       55
        
         strictDeps = true;

     

       28
       56
        
       

     

       29
       29
       -
         nativeBuildInputs =

     

       30
       30
       -
           [ makeWrapper pkg-config which

     

       31
       31
       -
             ocamlPackages.ocaml ocamlPackages.findlib ocamlPackages.menhir

     

       32
       32
       -
           ];

     

       57
       57
       +
         nativeBuildInputs = [

     

       58
       58
       +
           makeWrapper

     

       59
       59
       +
           pkg-config

     

       60
       60
       +
           which

     

       61
       61
       +
           ocamlPackages.ocaml

     

       62
       62
       +
           ocamlPackages.dune_3

     

       63
       63
       +
           ocamlPackages.findlib

     

       64
       64
       +
           ocamlPackages.menhir

     

       65
       65
       +
         ];

     

       33
       66
        
       

     

       34
       67
        
         buildInputs = [

     

       35
       68
        
           libjpeg

     
···

       38
       71
        
           ocamlPackages.dtools

     

       39
       72
        
           ocamlPackages.duppy

     

       40
       73
        
           ocamlPackages.mm

     

       41
       41
       -
           ocamlPackages.ocaml_pcre

     

       42
       42
       -
           ocamlPackages.menhir ocamlPackages.menhirLib

     

       43
       43
       -
           (ocamlPackages.camomile.override { version = "1.0.2"; })

     

       44
       74
        
           ocamlPackages.ocurl

     

       75
       75
       +
           ocamlPackages.cry

     

       76
       76
       +
           ocamlPackages.camomile

     

       45
       77
        
           ocamlPackages.uri

     

       46
       46
       -
           ocamlPackages.sedlex

     

       78
       78
       +
           ocamlPackages.fileutils

     

       79
       79
       +
           ocamlPackages.menhir # liquidsoap-lang

     

       80
       80
       +
           ocamlPackages.menhirLib

     

       81
       81
       +
           ocamlPackages.metadata

     

       82
       82
       +
           ocamlPackages.dune-build-info

     

       83
       83
       +
           ocamlPackages.re

     

       84
       84
       +
           ocamlPackages.sedlex # liquidsoap-lang

     

       85
       85
       +
           ocamlPackages.ppx_string

     

       47
       86
        
       

     

       48
       87
        
           # Recommended dependencies

     

       49
       88
        
           ocamlPackages.ffmpeg

     

       50
       89
        
       

     

       51
       90
        
           # Optional dependencies

     

       52
       52
       -
           ocamlPackages.camlimages

     

       53
       53
       -
           ocamlPackages.gd4o

     

       54
       91
        
           ocamlPackages.alsa

     

       55
       92
        
           ocamlPackages.ao

     

       56
       93
        
           ocamlPackages.bjack

     

       57
       57
       -
           ocamlPackages.cry

     

       94
       94
       +
           ocamlPackages.camlimages

     

       58
       95
        
           ocamlPackages.dssi

     

       59
       96
        
           ocamlPackages.faad

     

       60
       97
        
           ocamlPackages.fdkaac

     

       61
       98
        
           ocamlPackages.flac

     

       62
       99
        
           ocamlPackages.frei0r

     

       100
       100
       +
           ocamlPackages.gd4o

     

       101
       101
       +
           ocamlPackages.graphics

     

       63
       102
        
           ocamlPackages.gstreamer

     

       103
       103
       +
           ocamlPackages.imagelib

     

       64
       104
        
           ocamlPackages.inotify

     

       65
       105
        
           ocamlPackages.ladspa

     

       66
       106
        
           ocamlPackages.lame

     
···

       72
       112
        
           ocamlPackages.ogg

     

       73
       113
        
           ocamlPackages.opus

     

       74
       114
        
           ocamlPackages.portaudio

     

       115
       115
       +
           ocamlPackages.posix-time2

     

       75
       116
        
           ocamlPackages.pulseaudio

     

       117
       117
       +
           ocamlPackages.samplerate

     

       76
       118
        
           ocamlPackages.shine

     

       77
       77
       -
           ocamlPackages.samplerate

     

       78
       119
        
           ocamlPackages.soundtouch

     

       79
       120
        
           ocamlPackages.speex

     

       80
       121
        
           ocamlPackages.srt

     

       81
       122
        
           ocamlPackages.ssl

     

       82
       123
        
           ocamlPackages.taglib

     

       83
       124
        
           ocamlPackages.theora

     

       84
       84
       -
           ocamlPackages.vorbis

     

       85
       85
       -
           ocamlPackages.xmlplaylist

     

       86
       86
       -
           ocamlPackages.posix-time2

     

       87
       125
        
           ocamlPackages.tsdl

     

       88
       126
        
           ocamlPackages.tsdl-image

     

       89
       127
        
           ocamlPackages.tsdl-ttf

     

       90
       90
       -
       

     

       91
       91
       -
           # Undocumented dependencies

     

       92
       92
       -
           ocamlPackages.graphics

     

       93
       93
       -
           ocamlPackages.cohttp-lwt-unix

     

       128
       128
       +
           ocamlPackages.vorbis

     

       129
       129
       +
           ocamlPackages.xmlplaylist

     

       130
       130
       +
           ocamlPackages.yaml

     

       94
       131
        
         ];

     

       95
       132
        
       

     

       96
       133
        
         meta = with lib; {

+89 -5

pkgs/tools/misc/mstflint/default.nix

···

       1
       1
        
       { lib

     

       2
       2
        
       , stdenv

     

       3
       3
        
       , fetchurl

     

       4
       4
       -
       , libibmad

     

       4
       4
       +
       , rdma-core

     

       5
       5
        
       , openssl

     

       6
       6
        
       , zlib

     

       7
       7
       +
       , xz

     

       8
       8
       +
       , expat

     

       9
       9
       +
       , boost

     

       10
       10
       +
       , curl

     

       11
       11
       +
       , pkg-config

     

       12
       12
       +
       , libxml2

     

       13
       13
       +
       , pciutils

     

       14
       14
       +
       , busybox

     

       15
       15
       +
       , python3

     

       16
       16
       +
       , automake

     

       17
       17
       +
       , autoconf

     

       18
       18
       +
       , libtool

     

       19
       19
       +
       , git

     

       20
       20
       +
       # use this to shrink the package's footprint if necessary (e.g. for hardened appliances)

     

       21
       21
       +
       , onlyFirmwareUpdater ? false

     

       22
       22
       +
       # contains binary-only libraries

     

       23
       23
       +
       , enableDPA ? true

     

       7
       24
        
       }:

     

       8
       25
        
       

     

       9
       26
        
       stdenv.mkDerivation rec {

     

       10
       27
        
         pname = "mstflint";

     

       11
       11
       -
         version = "4.17.0-1";

     

       28
       28
       +
         version = "4.26.0-1";

     

       12
       29
        
       

     

       13
       30
        
         src = fetchurl {

     

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

     

       15
       15
       -
           sha256 = "030vpiv44sxmjf0dng91ziq1cggwj33yp0l4xc6cdhnrv2prjs7y";

     

       32
       32
       +
           hash = "sha256-P8XACcz6d8UTOhFFeTijfFOthBqnUghGlDj9K145sZ8=";

     

       16
       33
        
         };

     

       17
       34
        
       

     

       35
       35
       +
         nativeBuildInputs = [

     

       36
       36
       +
           autoconf

     

       37
       37
       +
           automake

     

       38
       38
       +
           libtool

     

       39
       39
       +
           pkg-config

     

       40
       40
       +
           libxml2

     

       41
       41
       +
           git

     

       42
       42
       +
         ];

     

       43
       43
       +
       

     

       18
       44
        
         buildInputs = [

     

       19
       19
       -
           libibmad

     

       45
       45
       +
           rdma-core

     

       46
       46
       +
           zlib

     

       47
       47
       +
           libxml2

     

       20
       48
        
           openssl

     

       21
       21
       -
           zlib

     

       49
       49
       +
         ] ++ lib.optionals (!onlyFirmwareUpdater) [

     

       50
       50
       +
           boost

     

       51
       51
       +
           curl

     

       52
       52
       +
           expat

     

       53
       53
       +
           xz

     

       54
       54
       +
           python3

     

       22
       55
        
         ];

     

       23
       56
        
       

     

       57
       57
       +
         preConfigure = ''

     

       58
       58
       +
           export CPPFLAGS="-I$(pwd)/tools_layouts -isystem ${libxml2.dev}/include/libxml2"

     

       59
       59
       +
           export INSTALL_BASEDIR=$out

     

       60
       60
       +
           ./autogen.sh

     

       61
       61
       +
         '';

     

       62
       62
       +
       

     

       63
       63
       +
         # Cannot use wrapProgram since the python script's logic depends on the

     

       64
       64
       +
         # filename and will get messed up if the executable is named ".xyz-wrapped".

     

       65
       65
       +
         # That is why the python executable and runtime dependencies are injected

     

       66
       66
       +
         # this way.

     

       67
       67
       +
         #

     

       68
       68
       +
         # Remove host_cpu replacement again (see https://github.com/Mellanox/mstflint/pull/865),

     

       69
       69
       +
         # needs to hit master or a release. master_devel may be rebased.

     

       70
       70
       +
         #

     

       71
       71
       +
         # Remove patch for regex check, after https://github.com/Mellanox/mstflint/pull/871

     

       72
       72
       +
         # got merged.

     

       73
       73
       +
         prePatch = [

     

       74
       74
       +
         ''

     

       75
       75
       +
           patchShebangs eval_git_sha.sh

     

       76
       76
       +
           substituteInPlace configure.ac \

     

       77
       77
       +
               --replace "build_cpu" "host_cpu"

     

       78
       78
       +
           substituteInPlace common/compatibility.h \

     

       79
       79
       +
               --replace "#define ROOT_PATH \"/\"" "#define ROOT_PATH \"$out/\""

     

       80
       80
       +
           substituteInPlace configure.ac \

     

       81
       81
       +
               --replace 'Whether to use GNU C regex])' 'Whether to use GNU C regex])],[AC_MSG_RESULT([yes])'

     

       82
       82
       +
         ''

     

       83
       83
       +
         (lib.optionals (!onlyFirmwareUpdater) ''

     

       84
       84
       +
           substituteInPlace common/python_wrapper.sh \

     

       85
       85
       +
             --replace \

     

       86
       86
       +
             'exec $PYTHON_EXEC $SCRIPT_PATH "$@"' \

     

       87
       87
       +
             'export PATH=$PATH:${lib.makeBinPath [ (placeholder "out") pciutils busybox]}; exec ${python3}/bin/python3 $SCRIPT_PATH "$@"'

     

       88
       88
       +
         '')

     

       89
       89
       +
         ];

     

       90
       90
       +
       

     

       91
       91
       +
         configureFlags = [

     

       92
       92
       +
           "--enable-xml2"

     

       93
       93
       +
           "--datarootdir=${placeholder "out"}/share"

     

       94
       94
       +
         ] ++ lib.optionals (!onlyFirmwareUpdater) [

     

       95
       95
       +
           "--enable-adb-generic-tools"

     

       96
       96
       +
           "--enable-cs"

     

       97
       97
       +
           "--enable-dc"

     

       98
       98
       +
           "--enable-fw-mgr"

     

       99
       99
       +
           "--enable-inband"

     

       100
       100
       +
           "--enable-rdmem"

     

       101
       101
       +
         ] ++ lib.optionals enableDPA [

     

       102
       102
       +
           "--enable-dpa"

     

       103
       103
       +
         ];

     

       104
       104
       +
       

     

       105
       105
       +
         enableParallelBuilding = true;

     

       106
       106
       +
       

     

       24
       107
        
         hardeningDisable = [ "format" ];

     

       25
       108
        
       

     

       26
       109
        
         dontDisableStatic = true;  # the build fails without this. should probably be reported upstream

     
···

       29
       112
        
           description = "Open source version of Mellanox Firmware Tools (MFT)";

     

       30
       113
        
           homepage = "https://github.com/Mellanox/mstflint";

     

       31
       114
        
           license = with licenses; [ gpl2 bsd2 ];

     

       115
       115
       +
           maintainers = with maintainers; [ thillux ];

     

       32
       116
        
           platforms = platforms.linux;

     

       33
       117
        
         };

     

       34
       118
        
       }

+5 -1

pkgs/tools/misc/plantuml-server/default.nix

···

       1
       1
       -
       { lib, stdenv, fetchurl }:

     

       1
       1
       +
       { lib, stdenv, fetchurl, nixosTests }:

     

       2
       2
        
       

     

       3
       3
        
       let

     

       4
       4
        
         version = "1.2023.12";

     
···

       16
       16
        
           mkdir -p "$out/webapps"

     

       17
       17
        
           cp "$src" "$out/webapps/plantuml.war"

     

       18
       18
        
         '';

     

       19
       19
       +
       

     

       20
       20
       +
         passthru.tests = {

     

       21
       21
       +
           inherit (nixosTests) plantuml-server;

     

       22
       22
       +
         };

     

       19
       23
        
       

     

       20
       24
        
         meta = with lib; {

     

       21
       25
        
           description = "A web application to generate UML diagrams on-the-fly.";

+2 -2

pkgs/tools/misc/qflipper/default.nix

···

       24
       24
        
       }:

     

       25
       25
        
       let

     

       26
       26
        
         pname = "qFlipper";

     

       27
       27
       -
         version = "1.3.2";

     

       28
       28
       -
         sha256 = "sha256-n/vvLR4p7ZmQC+FuYOvarmgydfYwxRBRktzs7CfiNQg=";

     

       27
       27
       +
         version = "1.3.3";

     

       28
       28
       +
         sha256 = "sha256-/Xzy+OA0Nl/UlSkOOZW2YsOHdJvS/7X3Z3ITkPByAOc=";

     

       29
       29
        
         timestamp = "99999999999";

     

       30
       30
        
         commit = "nix-${version}";

     

       31
       31

+2 -2

pkgs/tools/misc/ttyplot/default.nix

···

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation rec {

     

       4
       4
        
         pname = "ttyplot";

     

       5
       5
       -
         version = "1.5";

     

       5
       5
       +
         version = "1.5.1";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "tenox7";

     

       9
       9
        
           repo = "ttyplot";

     

       10
       10
        
           rev = version;

     

       11
       11
       -
           sha256 = "sha256-COnqzWqah1J/q64XrOBhMOsrafAs/BptqNvrjHJ9edQ=";

     

       11
       11
       +
           sha256 = "sha256-lZLjTmSKxGJhUMELcIPjycpuRR3m9oz/Vh1/FEUzMOQ=";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         buildInputs = [ ncurses ];

+4 -4

pkgs/tools/networking/containerlab/default.nix

···

       6
       6
        
       

     

       7
       7
        
       buildGoModule rec {

     

       8
       8
        
         pname = "containerlab";

     

       9
       9
       -
         version = "0.46.2";

     

       9
       9
       +
         version = "0.48.1";

     

       10
       10
        
       

     

       11
       11
        
         src = fetchFromGitHub {

     

       12
       12
        
           owner = "srl-labs";

     

       13
       13
        
           repo = "containerlab";

     

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

     

       15
       15
       -
           hash = "sha256-TzHTiAcN57FDdKBkZq5YwFwjP3s6OmN3431XGoMgnwI=";

     

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

     

       16
       16
        
         };

     

       17
       17
        
       

     

       18
       18
        
         nativeBuildInputs = [ installShellFiles ];

     

       19
       19
        
       

     

       20
       20
       -
         vendorHash = "sha256-3ALEwpFDnbSoTm3bxHZmRGkw1DeQ4Ikl6PpTosa1S6E=";

     

       20
       20
       +
         vendorHash = "sha256-w5lwZTSG6OI85P/swjK3NtovMqfgttr9DC+CPSKlpKQ=";

     

       21
       21
        
       

     

       22
       22
        
         ldflags = [

     

       23
       23
        
           "-s"

     
···

       41
       41
        
           changelog = "https://github.com/srl-labs/containerlab/releases/tag/${src.rev}";

     

       42
       42
        
           license = licenses.bsd3;

     

       43
       43
        
           platforms = platforms.linux;

     

       44
       44
       -
           maintainers = with maintainers; [ janik ];

     

       44
       44
       +
           maintainers = with maintainers; [ aaronjheng ];

     

       45
       45
        
         };

     

       46
       46
        
       }

+3 -3

pkgs/tools/networking/sing-box/default.nix

···

       11
       11
        
       

     

       12
       12
        
       buildGoModule rec {

     

       13
       13
        
         pname = "sing-box";

     

       14
       14
       -
         version = "1.6.4";

     

       14
       14
       +
         version = "1.6.5";

     

       15
       15
        
       

     

       16
       16
        
         src = fetchFromGitHub {

     

       17
       17
        
           owner = "SagerNet";

     

       18
       18
        
           repo = pname;

     

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

     

       20
       20
       -
           hash = "sha256-BYmEtdGaNfZ4QJMF1a+W1LjURh7HpFK1rS64CR46z1M=";

     

       20
       20
       +
           hash = "sha256-djbRt4VdrZ2a0yLbNaFNhKIN0AwuCCJATIcwFhnw5aM=";

     

       21
       21
        
         };

     

       22
       22
        
       

     

       23
       23
       -
         vendorHash = "sha256-aCYnr9Y6rxmTjY6Q/8IjYSmAVep/0ipitjjeArIhtPI=";

     

       23
       23
       +
         vendorHash = "sha256-qoW9+t427k5Ea9BhAdWIh+utD7EnIU1OLKJfsmYlEt8=";

     

       24
       24
        
       

     

       25
       25
        
         tags = [

     

       26
       26
        
           "with_quic"

+2 -2

pkgs/tools/networking/tgt/default.nix

···

       4
       4
        
       

     

       5
       5
        
       stdenv.mkDerivation rec {

     

       6
       6
        
         pname = "tgt";

     

       7
       7
       -
         version = "1.0.88";

     

       7
       7
       +
         version = "1.0.89";

     

       8
       8
        
       

     

       9
       9
        
         src = fetchFromGitHub {

     

       10
       10
        
           owner = "fujita";

     

       11
       11
        
           repo = pname;

     

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

     

       13
       13
       -
           sha256 = "sha256-tLc+viPufR6P5texDs9lU8wsOTzrjSK0Qz/r4/L8M5k=";

     

       13
       13
       +
           sha256 = "sha256-sgflHkG4FncQ31+BwcZsp7LRgqeqANCIKGysxUk8aEs=";

     

       14
       14
        
         };

     

       15
       15
        
       

     

       16
       16
        
         nativeBuildInputs = [ libxslt docbook_xsl makeWrapper ];

+8 -6

pkgs/top-level/all-packages.nix

···

       26567
       26567
        
       

     

       26568
       26568
        
         jboss_mysql_jdbc = callPackage ../servers/http/jboss/jdbc/mysql { };

     

       26569
       26569
        
       

     

       26570
       26570
       -
         jetty = callPackage ../servers/http/jetty { };

     

       26570
       26570
       +
         jetty = jetty_12;

     

       26571
       26571
       +
         jetty_12 = callPackage ../servers/http/jetty/12.x.nix { };

     

       26572
       26572
       +
         jetty_11 = callPackage ../servers/http/jetty/11.x.nix { };

     

       26571
       26573
        
       

     

       26572
       26574
        
         jibri = callPackage ../servers/jibri { };

     

       26573
       26575
        
       

     
···

       34243
       34245
        
         roxctl = callPackage ../applications/networking/cluster/roxctl {

     

       34244
       34246
        
         };

     

       34245
       34247
        
       

     

       34246
       34246
       -
         rqbit = callPackage ../applications/networking/p2p/rqbit {

     

       34247
       34247
       -
           inherit (darwin.apple_sdk.frameworks) Security;

     

       34248
       34248
       -
         };

     

       34249
       34249
       -
       

     

       34250
       34248
        
         rssguard = libsForQt5.callPackage ../applications/networking/feedreaders/rssguard { };

     

       34251
       34249
        
       

     

       34252
       34250
        
         scudcloud = callPackage ../applications/networking/instant-messengers/scudcloud { };

     
···

       36476
       36474
        
       

     

       36477
       36475
        
         webssh = with python3Packages; toPythonApplication webssh;

     

       36478
       36476
        
       

     

       36479
       36479
       -
         webtorrent_desktop = callPackage ../applications/video/webtorrent_desktop { };

     

       36477
       36477
       +
         webtorrent_desktop = callPackage ../applications/video/webtorrent_desktop {

     

       36478
       36478
       +
           electron = electron_27;

     

       36479
       36479
       +
         };

     

       36480
       36480
        
       

     

       36481
       36481
        
         wrapWeechat = callPackage ../applications/networking/irc/weechat/wrapper.nix { };

     

       36482
       36482
        
       

     
···

       39827
       39827
        
           stable = false;

     

       39828
       39828
        
           with3d = false;

     

       39829
       39829
        
         };

     

       39830
       39830
       +
       

     

       39831
       39831
       +
         kicadAddons = recurseIntoAttrs (callPackage ../applications/science/electronics/kicad/addons {});

     

       39830
       39832
        
       

     

       39831
       39833
        
         librepcb = libsForQt5.callPackage ../applications/science/electronics/librepcb { };

     

       39832
       39834

+2

pkgs/top-level/linux-kernels.nix

···

       381
       381
        
       

     

       382
       382
        
           lttng-modules = callPackage ../os-specific/linux/lttng-modules { };

     

       383
       383
        
       

     

       384
       384
       +
           mstflint_access = callPackage ../os-specific/linux/mstflint_access { };

     

       385
       385
       +
       

     

       384
       386
        
           broadcom_sta = callPackage ../os-specific/linux/broadcom-sta { };

     

       385
       387
        
       

     

       386
       388
        
           tbs = callPackage ../os-specific/linux/tbs { };

+2

pkgs/top-level/ocaml-packages.nix

···

       1046
       1046
        
       

     

       1047
       1047
        
           merlin-lib = callPackage ../development/tools/ocaml/merlin/lib.nix { };

     

       1048
       1048
        
       

     

       1049
       1049
       +
           metadata = callPackage ../development/ocaml-modules/metadata { };

     

       1050
       1050
       +
       

     

       1049
       1051
        
           metrics = callPackage ../development/ocaml-modules/metrics { };

     

       1050
       1052
        
       

     

       1051
       1053
        
           metrics-influx = callPackage ../development/ocaml-modules/metrics/influx.nix { };

+10

pkgs/top-level/python-packages.nix

···

       3657
       3657
        
       

     

       3658
       3658
        
         et-xmlfile = callPackage ../development/python-modules/et-xmlfile { };

     

       3659
       3659
        
       

     

       3660
       3660
       +
         euclid3 = callPackage ../development/python-modules/euclid3 { };

     

       3661
       3661
       +
       

     

       3660
       3662
        
         eufylife-ble-client = callPackage ../development/python-modules/eufylife-ble-client { };

     

       3661
       3663
        
       

     

       3662
       3664
        
         evaluate = callPackage ../development/python-modules/evaluate { };

     
···

       8842
       8844
        
           inherit (pkgs) libpcap; # Avoid confusion with python package of the same name

     

       8843
       8845
        
         };

     

       8844
       8846
        
       

     

       8847
       8847
       +
         pcbnew-transition = callPackage ../development/python-modules/pcbnew-transition { };

     

       8848
       8848
       +
       

     

       8845
       8849
        
         pcodedmp = callPackage ../development/python-modules/pcodedmp { };

     

       8846
       8850
        
       

     

       8847
       8851
        
         pcpp = callPackage ../development/python-modules/pcpp { };

     
···

       9008
       9012
        
       

     

       9009
       9013
        
         psrpcore = callPackage ../development/python-modules/psrpcore { };

     

       9010
       9014
        
       

     

       9015
       9015
       +
         pybars3 = callPackage ../development/python-modules/pybars3 { };

     

       9016
       9016
       +
       

     

       9017
       9017
       +
         pymeta3 = callPackage ../development/python-modules/pymeta3 { };

     

       9018
       9018
       +
       

     

       9011
       9019
        
         pypemicro = callPackage ../development/python-modules/pypemicro { };

     

       9012
       9020
        
       

     

       9013
       9021
        
         pyprecice = callPackage ../development/python-modules/pyprecice { };

     
···

       9110
       9118
        
         };

     

       9111
       9119
        
       

     

       9112
       9120
        
         pixelmatch = callPackage ../development/python-modules/pixelmatch { };

     

       9121
       9121
       +
       

     

       9122
       9122
       +
         pixel-ring = callPackage ../development/python-modules/pixel-ring { };

     

       9113
       9123
        
       

     

       9114
       9124
        
         pjsua2 = (toPythonModule (pkgs.pjsip.override {

     

       9115
       9125
        
           pythonSupport = true;