commit b31a0f36f881e3ed96ab064a2c43cb83bfcb40fb · pyrox.dev/nixpkgs

+24

pkgs/applications/networking/cluster/kube-capacity/default.nix

···

       1
       1
       +
       { stdenv, lib, buildGoModule, fetchFromGitHub }:

     

       2
       2
       +
       

     

       3
       3
       +
       buildGoModule rec {

     

       4
       4
       +
         pname = "kube-capacity";

     

       5
       5
       +
         version = "0.5.1";

     

       6
       6
       +
       

     

       7
       7
       +
         src = fetchFromGitHub {

     

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

     

       9
       9
       +
           owner = "robscott";

     

       10
       10
       +
           repo = pname;

     

       11
       11
       +
           sha256 = "127583hmpj04y522wir76a39frm6zg9z7mb4ny5lxxjqhn0q0cd5";

     

       12
       12
       +
         };

     

       13
       13
       +
       

     

       14
       14
       +
         vendorSha256 = "sha256-EgLWZs282IV1euCUCc5ucf267E2Z7GF9SgoImiGvuVM=";

     

       15
       15
       +
       

     

       16
       16
       +
         meta = with lib; {

     

       17
       17
       +
           description =

     

       18
       18
       +
             "A simple CLI that provides an overview of the resource requests, limits, and utilization in a Kubernetes cluster";

     

       19
       19
       +
           homepage = "https://github.com/robscott/kube-capacity";

     

       20
       20
       +
           changelog = "https://github.com/robscott/kube-capacity/releases/tag/v${version}";

     

       21
       21
       +
           license = licenses.asl20;

     

       22
       22
       +
           maintainers = [ maintainers.bryanasdev000 ];

     

       23
       23
       +
         };

     

       24
       24
       +
       }

+2 -2

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

···

       2
       2
        
       

     

       3
       3
        
       buildGoModule rec {

     

       4
       4
        
         pname = "starboard";

     

       5
       5
       -
         version = "0.9.1";

     

       5
       5
       +
         version = "0.9.2";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "aquasecurity";

     

       9
       9
        
           repo = pname;

     

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

     

       11
       11
       -
           sha256 = "sha256-ZIAdYuJ8LS8x2h+VXQrkgdmKkw9VKl7FcnOVZNSnXM0=";

     

       11
       11
       +
           sha256 = "sha256-w+xaZPEMmJYDPQG4MuAlWMhwhEyeVcpaeDwqsnIbIHA=";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         vendorSha256 = "sha256-aVKQcRZgxhIph+y28HhR15DUjwiz/4+t1bMrYXjPW7Q=";

+1 -1

pkgs/applications/networking/instant-messengers/element/element-desktop-package.json

···

       2
       2
        
         "name": "element-desktop",

     

       3
       3
        
         "productName": "Element",

     

       4
       4
        
         "main": "src/electron-main.js",

     

       5
       5
       -
         "version": "1.7.20",

     

       5
       5
       +
         "version": "1.7.21",

     

       6
       6
        
         "description": "A feature-rich client for Matrix.org",

     

       7
       7
        
         "author": "Element",

     

       8
       8
        
         "repository": {

+2 -2

pkgs/applications/networking/instant-messengers/element/element-desktop.nix

···

       8
       8
        
       

     

       9
       9
        
       let

     

       10
       10
        
         executableName = "element-desktop";

     

       11
       11
       -
         version = "1.7.20";

     

       11
       11
       +
         version = "1.7.21";

     

       12
       12
        
         src = fetchFromGitHub {

     

       13
       13
        
           owner = "vector-im";

     

       14
       14
        
           repo = "element-desktop";

     

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

     

       16
       16
       -
           sha256 = "sha256-kQMswcEGsefQ8HCWxYPgvxOKP5cgvXx8oCl5Inh6sOg=";

     

       16
       16
       +
           sha256 = "sha256-tpFiKaJB6KN97ipN3OCTyxpiS0b980MQ1Ynxj8CjCuI=";

     

       17
       17
        
         };

     

       18
       18
        
       in mkYarnPackage rec {

     

       19
       19
        
         name = "element-desktop-${version}";

+2 -2

pkgs/applications/networking/instant-messengers/element/element-web.nix

···

       12
       12
        
       

     

       13
       13
        
       in stdenv.mkDerivation rec {

     

       14
       14
        
         pname = "element-web";

     

       15
       15
       -
         version = "1.7.20";

     

       15
       15
       +
         version = "1.7.21";

     

       16
       16
        
       

     

       17
       17
        
         src = fetchurl {

     

       18
       18
        
           url = "https://github.com/vector-im/element-web/releases/download/v${version}/element-v${version}.tar.gz";

     

       19
       19
       -
           sha256 = "sha256-8R7l/Pmymd5+/Fri7z2/TDj1h2FL0QgLICoXajePing=";

     

       19
       19
       +
           sha256 = "sha256-JJXl+jDlXw8fZ1ZeeAACvilbqG9zanCmBsHy6BEla8M=";

     

       20
       20
        
         };

     

       21
       21
        
       

     

       22
       22
        
         installPhase = ''

+3 -3

pkgs/applications/networking/ncgopher/default.nix

···

       9
       9
        
       

     

       10
       10
        
       rustPlatform.buildRustPackage rec {

     

       11
       11
        
         pname = "ncgopher";

     

       12
       12
       -
         version = "0.1.5";

     

       12
       12
       +
         version = "0.2.0";

     

       13
       13
        
       

     

       14
       14
        
         src = fetchFromGitHub {

     

       15
       15
        
           owner = "jansc";

     

       16
       16
        
           repo = "ncgopher";

     

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

     

       18
       18
       -
           sha256 = "1mv89sanmr49b9za95jl5slpq960b246j2054r8xfafzqmbp44af";

     

       18
       18
       +
           sha256 = "sha256-Yny5zZe5x7/pWda839HcFkHFuL/jl1Q7ykTZzKy871I=";

     

       19
       19
        
         };

     

       20
       20
        
       

     

       21
       21
       -
         cargoSha256 = "12r4vgrg2bkr3p61yxcsg02kppg84vn956l0v1vb08i94rxzc8zk";

     

       21
       21
       +
         cargoSha256 = "sha256-IsRaDhnRamMSbtXG1r1j0jZYjFiSjRdwOaUVyqy4ZJw=";

     

       22
       22
        
       

     

       23
       23
        
         nativeBuildInputs = [ pkg-config ];

     

       24
       24
        
         buildInputs = [

+3 -3

pkgs/applications/version-management/git-and-tools/glab/default.nix

···

       2
       2
        
       

     

       3
       3
        
       buildGoModule rec {

     

       4
       4
        
         pname = "glab";

     

       5
       5
       -
         version = "1.14.0";

     

       5
       5
       +
         version = "1.15.0";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "profclems";

     

       9
       9
        
           repo = pname;

     

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

     

       11
       11
       -
           sha256 = "sha256-JvHuOMpt62tw7ewDev7unAgZGV+ZSo6wDuiPhWap2v0=";

     

       11
       11
       +
           sha256 = "sha256-wOeWqgN0VYmTXPTU3z5Utau8diW18QKV7w/2y86R8U0=";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
       -
         vendorSha256 = "sha256-0nnrH3GJhd4wlRETo9iSlFkXq358m30k7Fsb5haHlpQ=";

     

       14
       14
       +
         vendorSha256 = "sha256-Ge3nwI0cY2JxRTn3EZtlal5c6A6TIKfH/CkJnQ1C6PY=";

     

       15
       15
        
         runVend = true;

     

       16
       16
        
       

     

       17
       17
        
         # Tests are trying to access /homeless-shelter

+6 -14

pkgs/applications/video/cinelerra/default.nix

···

       1
       1
       -
       { lib, stdenv, fetchFromGitHub, fetchpatch, autoconf, automake, libtool

     

       1
       1
       +
       { lib, stdenv, fetchFromGitHub, autoconf, automake, libtool

     

       2
       2
        
       , pkg-config, faad2, faac, a52dec, alsaLib, fftw, lame, libavc1394

     

       3
       3
        
       , libiec61883, libraw1394, libsndfile, libvorbis, libogg, libjpeg

     

       4
       4
        
       , libtiff, freetype, mjpegtools, x264, gettext, openexr

     
···

       7
       7
        
       , fontconfig, intltool }:

     

       8
       8
        
       

     

       9
       9
        
       stdenv.mkDerivation {

     

       10
       10
       -
         name = "cinelerra-cv-2018-05-16";

     

       10
       10
       +
         name = "cinelerra-cv-2021-02-14";

     

       11
       11
        
       

     

       12
       12
        
         src = fetchFromGitHub {

     

       13
       13
        
           owner = "cinelerra-cv-team";

     

       14
       14
        
           repo = "cinelerra-cv";

     

       15
       15
       -
           rev = "d9c0dbf4393717f0a42f4b91c3e1ed5b16f955dc";

     

       16
       16
       -
           sha256 = "0a8kfm1v96sv6jh4568crg6nkr6n3579i9xksfj8w199s6yxzsbk";

     

       15
       15
       +
           rev = "7d0e8ede557d0cdf3606e0a8d97166a22f88d89e";

     

       16
       16
       +
           sha256 = "0n84y2wp47y89drc48cm1609gads5c6saw6c6bqcf5c5wcg1yfbj";

     

       17
       17
        
         };

     

       18
       18
       -
       

     

       19
       19
       -
         patches = [

     

       20
       20
       -
           # avoid gcc10 error about narrowing

     

       21
       21
       -
           (fetchpatch {

     

       22
       22
       -
             url = "https://github.com/cinelerra-cv-team/cinelerra-cv/pull/2/commits/a1b2d9c3bd5730ec0284894f3d81892af3e77f1f.patch";

     

       23
       23
       -
             sha256 = "1cjyv1m174dblpa1bs5dggk24h4477zqvc5sbfc0m5rpkndx5ycp";

     

       24
       24
       -
           })

     

       25
       25
       -
         ];

     

       26
       18
        
       

     

       27
       19
        
         preConfigure = ''

     

       28
       20
        
           find -type f -print0 | xargs --null sed -e "s@/usr/bin/perl@${perl}/bin/perl@" -i

     
···

       50
       42
        
           ];

     

       51
       43
        
       

     

       52
       44
        
         meta = with lib; {

     

       53
       53
       -
           description = "Video Editor";

     

       54
       54
       -
           homepage = "https://www.cinelerra.org/";

     

       45
       45
       +
           description = "Professional video editing and compositing environment (community version)";

     

       46
       46
       +
           homepage = "http://cinelerra-cv.wikidot.com/";

     

       55
       47
        
           maintainers = with maintainers; [ marcweber ];

     

       56
       48
        
           license = licenses.gpl2Only;

     

       57
       49
        
         };

+7 -4

pkgs/applications/virtualization/qemu/default.nix

···

       50
       50
        
           sha256 = "1g0pvx4qbirpcn9mni704y03n3lvkmw2c0rbcwvydyr8ns4xh66b";

     

       51
       51
        
         };

     

       52
       52
        
       

     

       53
       53
       -
         nativeBuildInputs = [ python python.pkgs.sphinx pkg-config flex bison meson ninja autoPatchelfHook ]

     

       54
       54
       -
           ++ optionals gtkSupport [ wrapGAppsHook ];

     

       53
       53
       +
         nativeBuildInputs = [ python python.pkgs.sphinx pkg-config flex bison meson ninja ]

     

       54
       54
       +
           ++ optionals gtkSupport [ wrapGAppsHook ]

     

       55
       55
       +
           ++ optionals stdenv.isLinux [ autoPatchelfHook ];

     

       55
       56
        
         buildInputs =

     

       56
       57
        
           [ zlib glib perl pixman

     

       57
       58
        
             vde2 texinfo makeWrapper lzo snappy

     
···

       108
       109
        
           # this script isn't marked as executable b/c it's indirectly used by meson. Needed to patch its shebang

     

       109
       110
        
           chmod +x ./scripts/shaderinclude.pl

     

       110
       111
        
           patchShebangs .

     

       112
       112
       +
           # avoid conflicts with libc++ include for <version>

     

       113
       113
       +
           mv VERSION QEMU_VERSION

     

       114
       114
       +
           substituteInPlace meson.build \

     

       115
       115
       +
             --replace "'VERSION'" "'QEMU_VERSION'"

     

       111
       116
        
         '' + optionalString stdenv.hostPlatform.isMusl ''

     

       112
       117
        
           NIX_CFLAGS_COMPILE+=" -D_LINUX_SYSINFO_H"

     

       113
       118
        
         '';

     
···

       119
       124
        
             "--enable-guest-agent"

     

       120
       125
        
             "--sysconfdir=/etc"

     

       121
       126
        
           ]

     

       122
       122
       -
           # disable sysctl check on darwin.

     

       123
       123
       -
           ++ optional stdenv.isDarwin "--cpu=x86_64"

     

       124
       127
        
           ++ optional numaSupport "--enable-numa"

     

       125
       128
        
           ++ optional seccompSupport "--enable-seccomp"

     

       126
       129
        
           ++ optional smartcardSupport "--enable-smartcard"

+2 -8

pkgs/data/icons/luna-icons/default.nix

···

       8
       8
        
       

     

       9
       9
        
       stdenv.mkDerivation rec {

     

       10
       10
        
         pname = "luna-icons";

     

       11
       11
       -
         version = "0.9.2";

     

       11
       11
       +
         version = "1.0";

     

       12
       12
        
       

     

       13
       13
        
         src = fetchFromGitHub {

     

       14
       14
        
           owner = "darkomarko42";

     

       15
       15
        
           repo = pname;

     

       16
       16
        
           rev = version;

     

       17
       17
       -
           sha256 = "0ajx7yjkgj5ynbjmd6k3cldjn0qr51h6k80hjgr7vqd0ybyylh5p";

     

       17
       17
       +
           sha256 = "1gggsd7scf15vrpgzvskx4p3jifnjdx0aqndqhvpc6ksdbh3nzqd";

     

       18
       18
        
         };

     

       19
       19
        
       

     

       20
       20
        
         nativeBuildInputs = [

     
···

       34
       34
        
       

     

       35
       35
        
           mkdir -p $out/share/icons

     

       36
       36
        
           cp -a Luna* $out/share/icons

     

       37
       37
       -
       

     

       38
       38
       -
           # remove files with spaces in the name, otherwise

     

       39
       39
       -
           # gtk-update-icon-cache fails with the message "The generated cache

     

       40
       40
       -
           # was invalid"

     

       41
       41
       -
           # https://github.com/darkomarko42/Luna-Icons/issues/2

     

       42
       42
       -
           rm "$out/share/icons/Luna/scalable/apps/yast-checkmedia (copia).svg"

     

       43
       37
        
       

     

       44
       38
        
           for theme in $out/share/icons/*; do

     

       45
       39
        
             gtk-update-icon-cache "$theme"

-41

pkgs/development/compilers/cudatoolkit/default.nix

···

       10
       10
        
       let

     

       11
       11
        
         common = callPackage ./common.nix;

     

       12
       12
        
       in rec {

     

       13
       13
       -
         cudatoolkit_6 = common {

     

       14
       14
       -
           version = "6.0.37";

     

       15
       15
       -
           url = "http://developer.download.nvidia.com/compute/cuda/6_0/rel/installers/cuda_6.0.37_linux_64.run";

     

       16
       16
       -
           sha256 = "991e436c7a6c94ec67cf44204d136adfef87baa3ded270544fa211179779bc40";

     

       17
       17
       -
           gcc = gcc48;

     

       18
       18
       -
         };

     

       19
       19
       -
       

     

       20
       20
       -
         cudatoolkit_6_5 = common {

     

       21
       21
       -
           version = "6.5.19";

     

       22
       22
       -
           url = "http://developer.download.nvidia.com/compute/cuda/6_5/rel/installers/cuda_6.5.19_linux_64.run";

     

       23
       23
       -
           sha256 = "1x9zdmk8z784d3d35vr2ak1l4h5v4jfjhpxfi9fl9dvjkcavqyaj";

     

       24
       24
       -
           gcc = gcc48;

     

       25
       25
       -
         };

     

       26
       26
       -
       

     

       27
       27
       -
         cudatoolkit_7 = common {

     

       28
       28
       -
           version = "7.0.28";

     

       29
       29
       -
           url = "http://developer.download.nvidia.com/compute/cuda/7_0/Prod/local_installers/cuda_7.0.28_linux.run";

     

       30
       30
       -
           sha256 = "1km5hpiimx11jcazg0h3mjzk220klwahs2vfqhjavpds5ff2wafi";

     

       31
       31
       -
           gcc = gcc6;

     

       32
       32
       -
         };

     

       33
       33
       -
       

     

       34
       34
       -
         cudatoolkit_7_5 = common {

     

       35
       35
       -
           version = "7.5.18";

     

       36
       36
       -
           url = "http://developer.download.nvidia.com/compute/cuda/7.5/Prod/local_installers/cuda_7.5.18_linux.run";

     

       37
       37
       -
           sha256 = "1v2ylzp34ijyhcxyh5p6i0cwawwbbdhni2l5l4qm21s1cx9ish88";

     

       38
       38
       -
           gcc = gcc6;

     

       39
       39
       -
         };

     

       40
       40
       -
       

     

       41
       41
       -
         cudatoolkit_8 = common {

     

       42
       42
       -
           version = "8.0.61.2";

     

       43
       43
       -
           url = "https://developer.nvidia.com/compute/cuda/8.0/Prod2/local_installers/cuda_8.0.61_375.26_linux-run";

     

       44
       44
       -
           sha256 = "1i4xrsqbad283qffvysn88w2pmxzxbbby41lw0j1113z771akv4w";

     

       45
       45
       -
           runPatches = [

     

       46
       46
       -
             (fetchurl {

     

       47
       47
       -
               url = "https://developer.nvidia.com/compute/cuda/8.0/Prod2/patches/2/cuda_8.0.61.2_linux-run";

     

       48
       48
       -
               sha256 = "1iaz5rrsnsb1p99qiqvxn6j3ksc7ry8xlr397kqcjzxqbljbqn9d";

     

       49
       49
       -
             })

     

       50
       50
       -
           ];

     

       51
       51
       -
           gcc = gcc6;

     

       52
       52
       -
         };

     

       53
       53
       -
       

     

       54
       13
        
         cudatoolkit_9_0 = common {

     

       55
       14
        
           version = "9.0.176.1";

     

       56
       15
        
           url = "https://developer.nvidia.com/compute/cuda/9.0/Prod/local_installers/cuda_9.0.176_384.81_linux-run";

+129 -582

pkgs/development/haskell-modules/hackage-packages.nix

···

       17052
       17052
        
       

     

       17053
       17053
        
         "Rattus" = callPackage

     

       17054
       17054
        
           ({ mkDerivation, base, Cabal, containers, ghc, ghc-prim

     

       17055
       17055
       -
            , simple-affine-space, transformers

     

       17055
       17055
       +
            , simple-affine-space

     

       17056
       17056
        
            }:

     

       17057
       17057
        
            mkDerivation {

     

       17058
       17058
        
              pname = "Rattus";

     

       17059
       17059
       -
              version = "0.5";

     

       17060
       17060
       -
              sha256 = "1dh6ln8awqhgnk7hqh4zdkv4pqy3wmsqbmqrd016raf8vjbc1i3m";

     

       17059
       17059
       +
              version = "0.4";

     

       17060
       17060
       +
              sha256 = "1sgr33yq5l43k3b8nwx7m6wrygv5k8d8yigzms3p6pq5pk3g5sq1";

     

       17061
       17061
        
              setupHaskellDepends = [ base Cabal ];

     

       17062
       17062
        
              libraryHaskellDepends = [

     

       17063
       17063
       -
                base containers ghc ghc-prim simple-affine-space transformers

     

       17063
       17063
       +
                base containers ghc ghc-prim simple-affine-space

     

       17064
       17064
        
              ];

     

       17065
       17065
        
              testHaskellDepends = [ base containers ];

     

       17066
       17066
        
              description = "A modal FRP language";

     
···

       21177
       21177
        
              platforms = lib.platforms.none;

     

       21178
       21178
        
            }) {};

     

       21179
       21179
        
       

     

       21180
       21180
       -
         "Win32_2_11_1_0" = callPackage

     

       21180
       21180
       +
         "Win32_2_11_0_0" = callPackage

     

       21181
       21181
        
           ({ mkDerivation }:

     

       21182
       21182
        
            mkDerivation {

     

       21183
       21183
        
              pname = "Win32";

     

       21184
       21184
       -
              version = "2.11.1.0";

     

       21185
       21185
       -
              sha256 = "18rsfx3ca8r7y4ifxn1mggn8j6ppgkn698wsq0pwqb63riva09rk";

     

       21184
       21184
       +
              version = "2.11.0.0";

     

       21185
       21185
       +
              sha256 = "179v0jypafjnh98gl8wr6z6pq1r5h740xzm2b6axd2d33zlnacfm";

     

       21186
       21186
        
              description = "A binding to Windows Win32 API";

     

       21187
       21187
        
              license = lib.licenses.bsd3;

     

       21188
       21188
        
              platforms = lib.platforms.none;

     
···

       24505
       24505
        
              license = lib.licenses.bsd3;

     

       24506
       24506
        
            }) {};

     

       24507
       24507
        
       

     

       24508
       24508
       -
         "aeson-combinators_0_0_4_1" = callPackage

     

       24509
       24509
       -
           ({ mkDerivation, aeson, base, bytestring, containers, criterion

     

       24510
       24510
       -
            , deepseq, doctest, fail, hspec, scientific, text, time

     

       24511
       24511
       -
            , time-compat, unordered-containers, utf8-string, uuid-types

     

       24512
       24512
       -
            , vector, void

     

       24513
       24513
       -
            }:

     

       24514
       24514
       -
            mkDerivation {

     

       24515
       24515
       -
              pname = "aeson-combinators";

     

       24516
       24516
       -
              version = "0.0.4.1";

     

       24517
       24517
       -
              sha256 = "1nvw5n7kfqrrci76350zd3mqvssb775ka4044kxgw0bhdzy3gcpg";

     

       24518
       24518
       -
              libraryHaskellDepends = [

     

       24519
       24519
       -
                aeson base bytestring containers fail scientific text time

     

       24520
       24520
       -
                time-compat unordered-containers uuid-types vector void

     

       24521
       24521
       -
              ];

     

       24522
       24522
       -
              testHaskellDepends = [

     

       24523
       24523
       -
                aeson base bytestring doctest hspec text utf8-string

     

       24524
       24524
       -
              ];

     

       24525
       24525
       -
              benchmarkHaskellDepends = [

     

       24526
       24526
       -
                aeson base bytestring criterion deepseq text

     

       24527
       24527
       -
              ];

     

       24528
       24528
       -
              description = "Aeson combinators for dead simple JSON decoding";

     

       24529
       24529
       -
              license = lib.licenses.bsd3;

     

       24530
       24530
       -
              hydraPlatforms = lib.platforms.none;

     

       24531
       24531
       -
            }) {};

     

       24532
       24532
       -
       

     

       24533
       24508
        
         "aeson-commit" = callPackage

     

       24534
       24509
        
           ({ mkDerivation, aeson, aeson-qq, base, mtl, tasty, tasty-hspec

     

       24535
       24510
        
            , text

     
···

       31899
       31874
        
            }:

     

       31900
       31875
        
            mkDerivation {

     

       31901
       31876
        
              pname = "approx";

     

       31902
       31902
       -
              version = "0.1.0.1";

     

       31903
       31903
       -
              sha256 = "0vzi0ai7lf7ji2lbf9v412fvrins7acy0dqs4j8ylfd1chck1w99";

     

       31877
       31877
       +
              version = "0.1.0.0";

     

       31878
       31878
       +
              sha256 = "1vc6k0w4zr355gfvprb5syh5jpmkdvp6wjibi4l95q9zwwdwhjn2";

     

       31904
       31879
        
              revision = "1";

     

       31905
       31905
       -
              editedCabalFile = "0kj9qqfv8fzg5b6l33avflxjlmd52wjsjridff1d5n071dnif37y";

     

       31880
       31880
       +
              editedCabalFile = "0k34bjsazp4wbv7zzmvh5vnqv7yzyq20h99q30mcrn4g2bvpc0q1";

     

       31906
       31881
        
              isLibrary = true;

     

       31907
       31882
        
              isExecutable = true;

     

       31908
       31883
        
              libraryHaskellDepends = [

     
···

       31915
       31890
        
                base containers hashable QuickCheck text time unordered-containers

     

       31916
       31891
        
                vector

     

       31917
       31892
        
              ];

     

       31918
       31918
       -
              description = "Easy-to-use emulation of approximate, ranges and tolerances in Haskell";

     

       31893
       31893
       +
              description = "Easy-to-use reasonable way of emulating approximate in Haskell";

     

       31919
       31894
        
              license = lib.licenses.mit;

     

       31920
       31895
        
              hydraPlatforms = lib.platforms.none;

     

       31921
       31896
        
              broken = true;

     
···

       33841
       33816
        
              pname = "asn1-encoding";

     

       33842
       33817
        
              version = "0.9.6";

     

       33843
       33818
        
              sha256 = "02nsr30h5yic1mk7znf0q4z3n560ip017n60hg7ya25rsfmxxy6r";

     

       33844
       33844
       -
              revision = "2";

     

       33845
       33845
       -
              editedCabalFile = "16503ryhq15f2rfdav2qnkq11dg2r3vk3f9v64q9dmxf8dh8zv97";

     

       33819
       33819
       +
              revision = "1";

     

       33820
       33820
       +
              editedCabalFile = "19nq8g1v323p47cqlc4m9r6li35dd3cmcd7k486jw24cijkdjm9n";

     

       33846
       33821
        
              libraryHaskellDepends = [ asn1-types base bytestring hourglass ];

     

       33847
       33822
        
              testHaskellDepends = [

     

       33848
       33823
        
                asn1-types base bytestring hourglass mtl tasty tasty-quickcheck

     
···

       34017
       33992
        
              pname = "assoc";

     

       34018
       33993
        
              version = "1.0.2";

     

       34019
       33994
        
              sha256 = "0kqlizznjy94fm8zr1ng633yxbinjff7cnsiaqs7m33ix338v66q";

     

       34020
       34020
       -
              revision = "1";

     

       34021
       34021
       -
              editedCabalFile = "17ycclzwnysca80frsyyb6sdd2r5p83lkgwxjjnjg6j62pvf8958";

     

       34022
       33995
        
              libraryHaskellDepends = [ base bifunctors tagged ];

     

       34023
       33996
        
              description = "swap and assoc: Symmetric and Semigroupy Bifunctors";

     

       34024
       33997
        
              license = lib.licenses.bsd3;

     
···

       47403
       47376
        
              broken = true;

     

       47404
       47377
        
            }) {};

     

       47405
       47378
        
       

     

       47406
       47406
       -
         "bytestring_0_11_1_0" = callPackage

     

       47407
       47407
       -
           ({ mkDerivation, base, deepseq, dlist, ghc-prim, integer-gmp

     

       47408
       47408
       -
            , random, tasty, tasty-bench, tasty-hunit, tasty-quickcheck

     

       47409
       47409
       -
            , transformers

     

       47410
       47410
       -
            }:

     

       47379
       47379
       +
         "bytestring_0_11_0_0" = callPackage

     

       47380
       47380
       +
           ({ mkDerivation, base, deepseq, ghc-prim, integer-gmp }:

     

       47411
       47381
        
            mkDerivation {

     

       47412
       47382
        
              pname = "bytestring";

     

       47413
       47413
       -
              version = "0.11.1.0";

     

       47414
       47414
       -
              sha256 = "1a29kwczd1hcpir691x936i9c5ys9d7m1lyby48djs9w54ksy1jw";

     

       47383
       47383
       +
              version = "0.11.0.0";

     

       47384
       47384
       +
              sha256 = "03fwkbn52946y2l1ddrqq1jp8l9bhgi0gwxpz1wqqsn6n2vz5rrj";

     

       47385
       47385
       +
              revision = "1";

     

       47386
       47386
       +
              editedCabalFile = "0qhx61v75cqpgrb88h5gpc4a6vg17dgrw555q2kgi2hvip61z5lr";

     

       47415
       47387
        
              libraryHaskellDepends = [ base deepseq ghc-prim integer-gmp ];

     

       47416
       47416
       -
              testHaskellDepends = [

     

       47417
       47417
       -
                base deepseq dlist ghc-prim tasty tasty-hunit tasty-quickcheck

     

       47418
       47418
       -
                transformers

     

       47419
       47419
       -
              ];

     

       47420
       47420
       -
              benchmarkHaskellDepends = [

     

       47421
       47421
       -
                base deepseq dlist random tasty-bench

     

       47422
       47422
       -
              ];

     

       47423
       47388
        
              description = "Fast, compact, strict and lazy byte strings with a list interface";

     

       47424
       47389
        
              license = lib.licenses.bsd3;

     

       47425
       47390
        
              hydraPlatforms = lib.platforms.none;

     
···

       50694
       50659
        
            }:

     

       50695
       50660
        
            mkDerivation {

     

       50696
       50661
        
              pname = "capnp";

     

       50697
       50697
       -
              version = "0.10.0.1";

     

       50698
       50698
       -
              sha256 = "1p5vx7gcswz08f790swb8pi2ckbphqr76j8gav4rvrbalscd3zvf";

     

       50662
       50662
       +
              version = "0.10.0.0";

     

       50663
       50663
       +
              sha256 = "054cy2rr2hg0brrbxff4my3q2fzr1qk7ik2xyip65dq54958ibqk";

     

       50699
       50664
        
              isLibrary = true;

     

       50700
       50665
        
              isExecutable = true;

     

       50701
       50666
        
              libraryHaskellDepends = [

     
···

       57140
       57105
        
              license = lib.licenses.bsd3;

     

       57141
       57106
        
            }) {};

     

       57142
       57107
        
       

     

       57143
       57143
       -
         "cmdargs_0_10_21" = callPackage

     

       57144
       57144
       -
           ({ mkDerivation, base, filepath, process, template-haskell

     

       57145
       57145
       -
            , transformers

     

       57146
       57146
       -
            }:

     

       57147
       57147
       -
            mkDerivation {

     

       57148
       57148
       -
              pname = "cmdargs";

     

       57149
       57149
       -
              version = "0.10.21";

     

       57150
       57150
       -
              sha256 = "0xfabq187n1vqrnnm4ciprpl0dcjq97rksyjnpcniwva9rffmn7p";

     

       57151
       57151
       -
              isLibrary = true;

     

       57152
       57152
       -
              isExecutable = true;

     

       57153
       57153
       -
              libraryHaskellDepends = [

     

       57154
       57154
       -
                base filepath process template-haskell transformers

     

       57155
       57155
       -
              ];

     

       57156
       57156
       -
              description = "Command line argument processing";

     

       57157
       57157
       -
              license = lib.licenses.bsd3;

     

       57158
       57158
       -
              hydraPlatforms = lib.platforms.none;

     

       57159
       57159
       -
            }) {};

     

       57160
       57160
       -
       

     

       57161
       57108
        
         "cmdargs-browser" = callPackage

     

       57162
       57109
        
           ({ mkDerivation, base, bytestring, cmdargs, directory, filepath

     

       57163
       57110
        
            , http-types, js-jquery, process, text, transformers, wai

     
···

       58092
       58039
        
            }:

     

       58093
       58040
        
            mkDerivation {

     

       58094
       58041
        
              pname = "coinbase-pro";

     

       58095
       58095
       -
              version = "0.9.0.0";

     

       58096
       58096
       -
              sha256 = "1wnjpm49gy75nl3m01bablchbk7clsgf4x53xqx5k2bsvn1xd1n1";

     

       58042
       58042
       +
              version = "0.8.0.0";

     

       58043
       58043
       +
              sha256 = "021c05qkrvgxlylvrrlb81bjxl49v5varn0fi5wqs5sda15766n3";

     

       58097
       58044
        
              isLibrary = true;

     

       58098
       58045
        
              isExecutable = true;

     

       58099
       58046
        
              libraryHaskellDepends = [

     
···

       65368
       65315
        
              license = lib.licenses.bsd3;

     

       65369
       65316
        
            }) {};

     

       65370
       65317
        
       

     

       65371
       65371
       -
         "criterion-cmp" = callPackage

     

       65372
       65372
       -
           ({ mkDerivation, ansi-terminal, base, boxes, bytestring, cassava

     

       65373
       65373
       -
            , containers, filepath, optparse-applicative, vector

     

       65374
       65374
       -
            }:

     

       65375
       65375
       -
            mkDerivation {

     

       65376
       65376
       -
              pname = "criterion-cmp";

     

       65377
       65377
       -
              version = "0.1.0.0";

     

       65378
       65378
       -
              sha256 = "0p9l9c89bg1n7xjdq3npvknlfb36gkvpgwhq7i0qd2g20ysdxppd";

     

       65379
       65379
       -
              isLibrary = false;

     

       65380
       65380
       -
              isExecutable = true;

     

       65381
       65381
       -
              executableHaskellDepends = [

     

       65382
       65382
       -
                ansi-terminal base boxes bytestring cassava containers filepath

     

       65383
       65383
       -
                optparse-applicative vector

     

       65384
       65384
       -
              ];

     

       65385
       65385
       -
              description = "A simple tool for comparing in Criterion benchmark results";

     

       65386
       65386
       -
              license = lib.licenses.bsd3;

     

       65387
       65387
       -
            }) {};

     

       65388
       65388
       -
       

     

       65389
       65318
        
         "criterion-compare" = callPackage

     

       65390
       65319
        
           ({ mkDerivation, base, bytestring, cassava, Chart, Chart-diagrams

     

       65391
       65320
        
            , clay, colour, containers, data-default, filepath, lens, lucid

     
···

       73688
       73617
        
              pname = "dhall";

     

       73689
       73618
        
              version = "1.38.0";

     

       73690
       73619
        
              sha256 = "0ifxi9i7ply640s2cgljjczvmblgz0ryp2p9yxgng3qm5ai58229";

     

       73691
       73691
       -
              revision = "2";

     

       73692
       73692
       -
              editedCabalFile = "13ppbn4kcrfls9fm9sqjwa4hb4nj8q6fqfxj3a62vck7qc1rbvn0";

     

       73620
       73620
       +
              revision = "1";

     

       73621
       73621
       +
              editedCabalFile = "067hh41cnmjskf3y3kzlwsisw6v5bh9mbmhg5jfapm1y5xp6gw9r";

     

       73693
       73622
        
              isLibrary = true;

     

       73694
       73623
        
              isExecutable = true;

     

       73695
       73624
        
              enableSeparateDataOutput = true;

     
···

       73731
       73660
        
              pname = "dhall-bash";

     

       73732
       73661
        
              version = "1.0.36";

     

       73733
       73662
        
              sha256 = "0hg45xjl1pcla9xbds40qrxcx2h6b4ysw8kbx8hpnaqaazr2jrw0";

     

       73734
       73734
       -
              revision = "1";

     

       73735
       73735
       -
              editedCabalFile = "1jc74gydr3yx01xp1a69a3g9mbfqyzsmv1053xm51bcxxv6p6z9d";

     

       73736
       73663
        
              isLibrary = true;

     

       73737
       73664
        
              isExecutable = true;

     

       73738
       73665
        
              libraryHaskellDepends = [

     
···

       73776
       73703
        
              pname = "dhall-docs";

     

       73777
       73704
        
              version = "1.0.4";

     

       73778
       73705
        
              sha256 = "0x6x5b9kh0in35jsgj2dghyxsqjdjrw7s9kngyjcn7v2ycklcifl";

     

       73779
       73779
       -
              revision = "3";

     

       73780
       73780
       -
              editedCabalFile = "116m74khdfx57ghrid1myqyj8acrhzhnjzjmxnsn3yghdan29797";

     

       73706
       73706
       +
              revision = "2";

     

       73707
       73707
       +
              editedCabalFile = "1y8aaph8zg3lp53apvkg0s6zviz3sa82qq1dnbqn6xjgb1dqjr7z";

     

       73781
       73708
        
              isLibrary = true;

     

       73782
       73709
        
              isExecutable = true;

     

       73783
       73710
        
              enableSeparateDataOutput = true;

     
···

       73843
       73770
        
              pname = "dhall-json";

     

       73844
       73771
        
              version = "1.7.5";

     

       73845
       73772
        
              sha256 = "1fpkp8xkcw2abcigypyl0ji6910jyshlqwhf48yfwn6dsgbyw6iy";

     

       73846
       73846
       -
              revision = "2";

     

       73847
       73847
       -
              editedCabalFile = "0181ma0qzkcfg4g5fcyivmjfn542m9cmq74r6hxilfjvfzhk7fqw";

     

       73773
       73773
       +
              revision = "1";

     

       73774
       73774
       +
              editedCabalFile = "0vl9vb84r1fz80jvqxaq4624pk67hxkm3vsx5j0l3bz8mk439yzn";

     

       73848
       73775
        
              isLibrary = true;

     

       73849
       73776
        
              isExecutable = true;

     

       73850
       73777
        
              libraryHaskellDepends = [

     
···

       73894
       73821
        
              pname = "dhall-lsp-server";

     

       73895
       73822
        
              version = "1.0.13";

     

       73896
       73823
        
              sha256 = "0cj51xdmpp0w7ndzbz4yn882agvhbnsss3myqlhfi4y91lb8f1ak";

     

       73897
       73897
       -
              revision = "3";

     

       73898
       73898
       -
              editedCabalFile = "19c902vjdnikwma21gjggpc7x9sjdqbirksqw85f1n9jkrbya375";

     

       73824
       73824
       +
              revision = "2";

     

       73825
       73825
       +
              editedCabalFile = "1gmcfp6i36y00z4gyllcq62rgpjz2x7fgdy4n6d24ygczpqbwy9k";

     

       73899
       73826
        
              isLibrary = true;

     

       73900
       73827
        
              isExecutable = true;

     

       73901
       73828
        
              libraryHaskellDepends = [

     
···

       74038
       73965
        
              pname = "dhall-yaml";

     

       74039
       73966
        
              version = "1.2.5";

     

       74040
       73967
        
              sha256 = "0fax4p85344yrzk1l21j042mm02p0idp396vkq71x3dpiniq0mwf";

     

       74041
       74041
       -
              revision = "1";

     

       74042
       74042
       -
              editedCabalFile = "034rykrnmsnc9v9hsblkzjp26b8wv265sd31gwhqxy2358y4s33h";

     

       74043
       73968
        
              isLibrary = true;

     

       74044
       73969
        
              isExecutable = true;

     

       74045
       73970
        
              libraryHaskellDepends = [

     
···

       74742
       74667
        
              ];

     

       74743
       74668
        
              description = "Pure Haskell solver routines used by diagrams";

     

       74744
       74669
        
              license = lib.licenses.bsd3;

     

       74745
       74745
       -
            }) {};

     

       74746
       74746
       -
       

     

       74747
       74747
       -
         "diagrams-solve_0_1_3" = callPackage

     

       74748
       74748
       -
           ({ mkDerivation, base, deepseq, tasty, tasty-hunit

     

       74749
       74749
       -
            , tasty-quickcheck

     

       74750
       74750
       -
            }:

     

       74751
       74751
       -
            mkDerivation {

     

       74752
       74752
       -
              pname = "diagrams-solve";

     

       74753
       74753
       -
              version = "0.1.3";

     

       74754
       74754
       -
              sha256 = "09qqwcvbvd3a0j5fnp40dbzw0i3py9c7kgizj2aawajwbyjvpd17";

     

       74755
       74755
       -
              libraryHaskellDepends = [ base ];

     

       74756
       74756
       -
              testHaskellDepends = [

     

       74757
       74757
       -
                base deepseq tasty tasty-hunit tasty-quickcheck

     

       74758
       74758
       -
              ];

     

       74759
       74759
       -
              description = "Pure Haskell solver routines used by diagrams";

     

       74760
       74760
       -
              license = lib.licenses.bsd3;

     

       74761
       74761
       -
              hydraPlatforms = lib.platforms.none;

     

       74762
       74670
        
            }) {};

     

       74763
       74671
        
       

     

       74764
       74672
        
         "diagrams-svg" = callPackage

     
···

       85824
       85732
        
       

     

       85825
       85733
        
         "evdev" = callPackage

     

       85826
       85734
        
           ({ mkDerivation, base, bytestring, c2hs, containers, extra

     

       85827
       85827
       -
            , filepath-bytestring, libevdev, monad-loops, rawfilepath, tasty

     

       85828
       85828
       -
            , tasty-hunit, tasty-quickcheck, time, unix

     

       85735
       85735
       +
            , libevdev, monad-loops, time, unix

     

       85829
       85736
        
            }:

     

       85830
       85737
        
            mkDerivation {

     

       85831
       85738
        
              pname = "evdev";

     

       85832
       85832
       -
              version = "2.1.0";

     

       85833
       85833
       -
              sha256 = "1gzf9hpsi2dmcgsifq5z91ing9b5k56mm2hx9wbsa180pmq30lj3";

     

       85739
       85739
       +
              version = "2.0.0.1";

     

       85740
       85740
       +
              sha256 = "0ryq50g7z70rnv07pnvwssl0qrvhbljkq9yk1z8gj9kvqdsw9cmg";

     

       85834
       85741
        
              libraryHaskellDepends = [

     

       85835
       85835
       -
                base bytestring containers extra filepath-bytestring monad-loops

     

       85836
       85836
       -
                rawfilepath time unix

     

       85742
       85742
       +
                base bytestring containers extra monad-loops time unix

     

       85837
       85743
        
              ];

     

       85838
       85744
        
              libraryPkgconfigDepends = [ libevdev ];

     

       85839
       85745
        
              libraryToolDepends = [ c2hs ];

     

       85840
       85840
       -
              testHaskellDepends = [

     

       85841
       85841
       -
                base bytestring containers extra filepath-bytestring monad-loops

     

       85842
       85842
       -
                rawfilepath tasty tasty-hunit tasty-quickcheck time unix

     

       85843
       85843
       -
              ];

     

       85844
       85746
        
              description = "Bindings to libevdev";

     

       85845
       85747
        
              license = lib.licenses.bsd3;

     

       85846
       85748
        
            }) {inherit (pkgs) libevdev;};

     
···

       85853
       85755
        
              pname = "evdev-streamly";

     

       85854
       85756
        
              version = "0.0.1.0";

     

       85855
       85757
        
              sha256 = "1bzmxkg5y7w6v5l6q5vzhr19j5vwbx4p4qxdq72f7f714ihn8nyp";

     

       85856
       85856
       -
              revision = "1";

     

       85857
       85857
       -
              editedCabalFile = "02xnb49zwr39ziq2xrwnnddzxr1ppwig441i3074g1w0ng5cf2gj";

     

       85858
       85758
        
              libraryHaskellDepends = [

     

       85859
       85759
        
                base bytestring containers evdev extra posix-paths rawfilepath

     

       85860
       85760
        
                streamly streamly-fsnotify unix

     
···

       86822
       86722
        
            }:

     

       86823
       86723
        
            mkDerivation {

     

       86824
       86724
        
              pname = "exh";

     

       86825
       86825
       -
              version = "1.0.2";

     

       86826
       86826
       -
              sha256 = "10pvr8ya2f7arp8cqi4g97dpqin1h8n0xmnihqszchcils0v2ayn";

     

       86725
       86725
       +
              version = "1.0.0";

     

       86726
       86726
       +
              sha256 = "0s5br96spx4v67mvl09w4kpcwvps65zp6qx5qpvrq63a0ncclp7l";

     

       86827
       86727
        
              libraryHaskellDepends = [

     

       86828
       86728
        
                aeson base bytestring conduit containers html-conduit http-client

     

       86829
       86729
        
                in-other-words language-javascript megaparsec optics-core optics-th

     
···

       101593
       101493
        
              license = lib.licenses.bsd2;

     

       101594
       101494
        
            }) {};

     

       101595
       101495
        
       

     

       101596
       101596
       -
         "ghc-typelits-natnormalise_0_7_4" = callPackage

     

       101597
       101597
       -
           ({ mkDerivation, base, containers, ghc, ghc-tcplugins-extra

     

       101598
       101598
       -
            , integer-gmp, tasty, tasty-hunit, template-haskell, transformers

     

       101599
       101599
       -
            }:

     

       101600
       101600
       -
            mkDerivation {

     

       101601
       101601
       -
              pname = "ghc-typelits-natnormalise";

     

       101602
       101602
       -
              version = "0.7.4";

     

       101603
       101603
       -
              sha256 = "0d8wwb1i6jj11cylf2n42r08hfygv9gwy89xyxp4kdclyw9mfwrp";

     

       101604
       101604
       -
              libraryHaskellDepends = [

     

       101605
       101605
       -
                base containers ghc ghc-tcplugins-extra integer-gmp transformers

     

       101606
       101606
       -
              ];

     

       101607
       101607
       -
              testHaskellDepends = [ base tasty tasty-hunit template-haskell ];

     

       101608
       101608
       -
              description = "GHC typechecker plugin for types of kind GHC.TypeLits.Nat";

     

       101609
       101609
       -
              license = lib.licenses.bsd2;

     

       101610
       101610
       -
              hydraPlatforms = lib.platforms.none;

     

       101611
       101611
       -
            }) {};

     

       101612
       101612
       -
       

     

       101613
       101496
        
         "ghc-typelits-presburger" = callPackage

     

       101614
       101497
        
           ({ mkDerivation, base, containers, equational-reasoning, ghc

     

       101615
       101498
        
            , ghc-tcplugins-extra, mtl, pretty, reflection, syb, tasty

     
···

       102293
       102176
        
       

     

       102294
       102177
        
         "ghcprofview" = callPackage

     

       102295
       102178
        
           ({ mkDerivation, aeson, base, containers, ghc-prof, gi-gtk

     

       102296
       102296
       -
            , haskell-gi-base, mtl, regex-tdfa, scientific, text

     

       102179
       102179
       +
            , haskell-gi-base, regex-tdfa, regex-tdfa-text, scientific, text

     

       102297
       102180
        
            }:

     

       102298
       102181
        
            mkDerivation {

     

       102299
       102182
        
              pname = "ghcprofview";

     

       102300
       102300
       -
              version = "0.1.0.1";

     

       102301
       102301
       -
              sha256 = "0lk5ky0vrymzhdzfrdvq25kpphg69f1m6524jhr57dnss5syz1iv";

     

       102183
       102183
       +
              version = "0.1.0.0";

     

       102184
       102184
       +
              sha256 = "103186dik439sdzz1w6dr98s1sfghjxdkp51mh18wrcwdbdb9r3a";

     

       102302
       102185
        
              isLibrary = false;

     

       102303
       102186
        
              isExecutable = true;

     

       102304
       102187
        
              executableHaskellDepends = [

     

       102305
       102305
       -
                aeson base containers ghc-prof gi-gtk haskell-gi-base mtl

     

       102306
       102306
       -
                regex-tdfa scientific text

     

       102188
       102188
       +
                aeson base containers ghc-prof gi-gtk haskell-gi-base regex-tdfa

     

       102189
       102189
       +
                regex-tdfa-text scientific text

     

       102307
       102190
        
              ];

     

       102308
       102191
        
              description = "GHC .prof files viewer";

     

       102309
       102192
        
              license = lib.licenses.bsd3;

     
···

       105670
       105553
        
            }:

     

       105671
       105554
        
            mkDerivation {

     

       105672
       105555
        
              pname = "gltf-codec";

     

       105673
       105673
       -
              version = "0.1.0.3";

     

       105674
       105674
       -
              sha256 = "0kgkzskn2k9zgihrb1v9xy5yfjlggmpj15g1bdgx7faipksaa3fb";

     

       105556
       105556
       +
              version = "0.1.0.2";

     

       105557
       105557
       +
              sha256 = "07zf9lzin22clixmvgvam6h995jfq2wzqz4498qv60jlcj88zzmh";

     

       105675
       105558
        
              libraryHaskellDepends = [

     

       105676
       105559
        
                aeson base base64-bytestring binary bytestring scientific text

     

       105677
       105560
        
                unordered-containers vector

     
···

       115913
       115796
        
            }:

     

       115914
       115797
        
            mkDerivation {

     

       115915
       115798
        
              pname = "happstack-authenticate";

     

       115916
       115916
       -
              version = "2.4.1.1";

     

       115917
       115917
       -
              sha256 = "164pjybk054a3h3ydfakzibngpmp8a4cbzg0sip9slfb739nz25j";

     

       115799
       115799
       +
              version = "2.4.1";

     

       115800
       115800
       +
              sha256 = "1166ccqpjwr331chf7hi4n42m2frahpf93ardfjgv8x6d0p5pfss";

     

       115918
       115801
        
              enableSeparateDataOutput = true;

     

       115919
       115802
        
              libraryHaskellDepends = [

     

       115920
       115803
        
                acid-state aeson authenticate base base64-bytestring boomerang

     
···

       118454
       118337
        
              pname = "haskell-language-server";

     

       118455
       118338
        
              version = "0.9.0.0";

     

       118456
       118339
        
              sha256 = "0wzwadmrw57dqp9mszr4nmcnrwa01kav70z0wqkh8g2ag0kv3nfm";

     

       118457
       118457
       -
              revision = "3";

     

       118458
       118458
       -
              editedCabalFile = "02dvw9d9c7wja6y8q5ncjks5hjxjplnfn9jnw9cqzfyi97pv4cm6";

     

       118459
       118340
        
              isLibrary = true;

     

       118460
       118341
        
              isExecutable = true;

     

       118461
       118342
        
              libraryHaskellDepends = [

     
···

       120298
       120179
        
       

     

       120299
       120180
        
         "haskellish" = callPackage

     

       120300
       120181
        
           ({ mkDerivation, base, containers, haskell-src-exts, mtl

     

       120301
       120301
       -
            , template-haskell, text

     

       120182
       120182
       +
            , template-haskell

     

       120302
       120183
        
            }:

     

       120303
       120184
        
            mkDerivation {

     

       120304
       120185
        
              pname = "haskellish";

     

       120305
       120305
       -
              version = "0.2.4.2";

     

       120306
       120306
       -
              sha256 = "1d7rpb9l1ycmcr8ahxjb5p2v3qdlwnjdxkm292bnakvwazgnq7cw";

     

       120186
       120186
       +
              version = "0.2.3.1";

     

       120187
       120187
       +
              sha256 = "0285mk3s1gl0xxwcqd22v800pcg75ml676nzs5pb96ybfniqksl0";

     

       120307
       120188
        
              libraryHaskellDepends = [

     

       120308
       120308
       -
                base containers haskell-src-exts mtl template-haskell text

     

       120189
       120189
       +
                base containers haskell-src-exts mtl template-haskell

     

       120309
       120190
        
              ];

     

       120310
       120191
        
              description = "For parsing Haskell-ish languages";

     

       120311
       120192
        
              license = lib.licenses.bsd3;

     
···

       120785
       120666
        
            }:

     

       120786
       120667
        
            mkDerivation {

     

       120787
       120668
        
              pname = "haskoin-store";

     

       120788
       120788
       -
              version = "0.46.0";

     

       120789
       120789
       -
              sha256 = "18iig8wbbgknzgzjxicjhpbhp7a9wzq1nrvixfwf4gpdlxmzq18y";

     

       120669
       120669
       +
              version = "0.42.2";

     

       120670
       120670
       +
              sha256 = "03xys3m0cdkjbabcrgc96sdb8ws3rrzq794ggnkwigwzgnav0gm0";

     

       120790
       120671
        
              isLibrary = true;

     

       120791
       120672
        
              isExecutable = true;

     

       120792
       120673
        
              libraryHaskellDepends = [

     
···

       120830
       120711
        
            }:

     

       120831
       120712
        
            mkDerivation {

     

       120832
       120713
        
              pname = "haskoin-store-data";

     

       120833
       120833
       -
              version = "0.45.0";

     

       120834
       120834
       -
              sha256 = "1hzlc8w9xmbwsvz6j74pxbkxla9a0wdgill81vn8g3zk4r7z0xx5";

     

       120714
       120714
       +
              version = "0.42.1";

     

       120715
       120715
       +
              sha256 = "17yfbd4vp9xx551bybpkiiv6w1x8067xmyrfff7zak3glzb3piva";

     

       120835
       120716
        
              libraryHaskellDepends = [

     

       120836
       120717
        
                aeson base bytestring cereal containers data-default deepseq

     

       120837
       120718
        
                hashable haskoin-core http-client http-types lens mtl network

     
···

       127152
       127033
        
              license = lib.licenses.bsd3;

     

       127153
       127034
        
            }) {};

     

       127154
       127035
        
       

     

       127155
       127155
       -
         "hie-bios_0_7_3" = callPackage

     

       127156
       127156
       -
           ({ mkDerivation, aeson, base, base16-bytestring, bytestring

     

       127157
       127157
       -
            , conduit, conduit-extra, containers, cryptohash-sha1, deepseq

     

       127158
       127158
       -
            , directory, extra, file-embed, filepath, ghc, hslogger

     

       127159
       127159
       -
            , hspec-expectations, optparse-applicative, process, tasty

     

       127160
       127160
       -
            , tasty-expected-failure, tasty-hunit, temporary, text, time

     

       127161
       127161
       -
            , transformers, unix-compat, unordered-containers, vector, yaml

     

       127162
       127162
       -
            }:

     

       127163
       127163
       -
            mkDerivation {

     

       127164
       127164
       -
              pname = "hie-bios";

     

       127165
       127165
       -
              version = "0.7.3";

     

       127166
       127166
       -
              sha256 = "0njgxy8dx43smqk4wv3zg0c8a7llbgnz4fbil9dw53yx2xncgapi";

     

       127167
       127167
       -
              isLibrary = true;

     

       127168
       127168
       -
              isExecutable = true;

     

       127169
       127169
       -
              libraryHaskellDepends = [

     

       127170
       127170
       -
                aeson base base16-bytestring bytestring conduit conduit-extra

     

       127171
       127171
       -
                containers cryptohash-sha1 deepseq directory extra file-embed

     

       127172
       127172
       -
                filepath ghc hslogger process temporary text time transformers

     

       127173
       127173
       -
                unix-compat unordered-containers vector yaml

     

       127174
       127174
       -
              ];

     

       127175
       127175
       -
              executableHaskellDepends = [

     

       127176
       127176
       -
                base directory filepath ghc optparse-applicative

     

       127177
       127177
       -
              ];

     

       127178
       127178
       -
              testHaskellDepends = [

     

       127179
       127179
       -
                base directory extra filepath ghc hspec-expectations tasty

     

       127180
       127180
       -
                tasty-expected-failure tasty-hunit temporary text

     

       127181
       127181
       -
                unordered-containers yaml

     

       127182
       127182
       -
              ];

     

       127183
       127183
       -
              description = "Set up a GHC API session";

     

       127184
       127184
       -
              license = lib.licenses.bsd3;

     

       127185
       127185
       -
              hydraPlatforms = lib.platforms.none;

     

       127186
       127186
       -
            }) {};

     

       127187
       127187
       -
       

     

       127188
       127036
        
         "hie-compat" = callPackage

     

       127189
       127037
        
           ({ mkDerivation, array, base, bytestring, containers, directory

     

       127190
       127038
        
            , filepath, ghc, ghc-boot, transformers

     
···

       127901
       127749
        
       

     

       127902
       127750
        
         "hinit" = callPackage

     

       127903
       127751
        
           ({ mkDerivation, base, Cabal, containers, directory, exceptions

     

       127904
       127904
       -
            , fused-effects, Glob, haskeline, megaparsec, mustache, optics-core

     

       127905
       127905
       -
            , optparse-applicative, parser-combinators, path, path-io

     

       127752
       127752
       +
            , fused-effects, generic-lens, Glob, haskeline, lens, megaparsec

     

       127753
       127753
       +
            , mustache, optparse-applicative, parser-combinators, path, path-io

     

       127906
       127754
        
            , prettyprinter, prettyprinter-ansi-terminal, process

     

       127907
       127755
        
            , quickcheck-text, spdx-license, string-interpolate, text, time

     

       127908
       127756
        
            , tomland

     

       127909
       127757
        
            }:

     

       127910
       127758
        
            mkDerivation {

     

       127911
       127759
        
              pname = "hinit";

     

       127912
       127912
       -
              version = "0.2.1";

     

       127913
       127913
       -
              sha256 = "10lhx18g50f24l867kjqgb2qpky3vvx7w7s4sc3pidr3hc0ams3g";

     

       127760
       127760
       +
              version = "0.2.0";

     

       127761
       127761
       +
              sha256 = "1iklwj1kzv7nbb4bnrj0idfb0k26jjpw51mkbib73j4jpciah01v";

     

       127914
       127762
        
              isLibrary = true;

     

       127915
       127763
        
              isExecutable = true;

     

       127916
       127764
        
              enableSeparateDataOutput = true;

     

       127917
       127765
        
              libraryHaskellDepends = [

     

       127918
       127918
       -
                base Cabal containers directory exceptions fused-effects Glob

     

       127919
       127919
       -
                haskeline megaparsec mustache optics-core optparse-applicative

     

       127920
       127920
       -
                parser-combinators path path-io prettyprinter

     

       127766
       127766
       +
                base Cabal containers directory exceptions fused-effects

     

       127767
       127767
       +
                generic-lens Glob haskeline lens megaparsec mustache

     

       127768
       127768
       +
                optparse-applicative parser-combinators path path-io prettyprinter

     

       127921
       127769
        
                prettyprinter-ansi-terminal process spdx-license string-interpolate

     

       127922
       127770
        
                text time tomland

     

       127923
       127771
        
              ];

     
···

       134342
       134190
        
              license = lib.licenses.bsd3;

     

       134343
       134191
        
              hydraPlatforms = lib.platforms.none;

     

       134344
       134192
        
              broken = true;

     

       134345
       134345
       -
            }) {};

     

       134346
       134346
       -
       

     

       134347
       134347
       -
         "kdesrc-build-profiles" = callPackage

     

       134348
       134348
       -
         "kdesrc-build-profiles" = callPackage

     

       134349
       134349
       -
            mkDerivation {

     

       134350
       134350
       -
         "kdesrc-build-profiles" = callPackage

     

       134351
       134351
       -
              version = "0.1.0.0";

     

       134352
       134352
       -
         "kdesrc-build-profiles" = callPackage

     

       134353
       134353
       -
         "kdesrc-build-profiles" = callPackage

     

       134354
       134354
       -
         "kdesrc-build-profiles" = callPackage

     

       134355
       134355
       -
         "kdesrc-build-profiles" = callPackage

     

       134356
       134356
       -
              license = lib.licenses.bsd3;

     

       134357
       134193
        
            }) {};

     

       134358
       134194
        
       

     

       134359
       134195
        
         "kdesrc-build-profiles" = callPackage

     
···

       143838
       143674
        
              broken = true;

     

       143839
       143675
        
            }) {};

     

       143840
       143676
        
       

     

       143841
       143841
       -
         "ice40-prim" = callPackage

     

       143842
       143842
       -
           ({ mkDerivation, base, Cabal, clash-prelude, ghc-typelits-extra

     

       143843
       143843
       -
            , ghc-typelits-knownnat, ghc-typelits-natnormalise, interpolate

     

       143844
       143844
       -
            }:

     

       143845
       143845
       -
            mkDerivation {

     

       143846
       143846
       -
              pname = "ice40-prim";

     

       143847
       143847
       -
              version = "0.1.0.0";

     

       143848
       143848
       -
              sha256 = "00l0kwwayf0bark2yqjrx8imr8997d5mrnhjf3zsayxk9a521j99";

     

       143849
       143849
       -
              libraryHaskellDepends = [

     

       143850
       143850
       -
                base Cabal clash-prelude ghc-typelits-extra ghc-typelits-knownnat

     

       143851
       143851
       -
                ghc-typelits-natnormalise interpolate

     

       143852
       143852
       -
              ];

     

       143853
       143853
       -
              description = "Lattice iCE40 Primitive IP";

     

       143854
       143854
       -
              license = lib.licenses.bsd3;

     

       143855
       143855
       -
            }) {};

     

       143856
       143856
       -
       

     

       143857
       143677
        
         "icepeak" = callPackage

     

       143858
       143678
        
           ({ mkDerivation, aeson, async, base, bytestring, containers

     

       143859
       143679
        
            , directory, hashable, hspec, hspec-core, hspec-expectations

     
···

       150882
       150702
        
              license = lib.licenses.mit;

     

       150883
       150703
        
            }) {};

     

       150884
       150704
        
       

     

       150885
       150885
       -
         "jira-wiki-markup_1_3_3" = callPackage

     

       150886
       150886
       -
           ({ mkDerivation, base, mtl, parsec, tasty, tasty-hunit, text }:

     

       150887
       150887
       -
            mkDerivation {

     

       150888
       150888
       -
              pname = "jira-wiki-markup";

     

       150889
       150889
       -
              version = "1.3.3";

     

       150890
       150890
       -
              sha256 = "0sgm9x2bdwazhj598aix2xyshjy6cvai4sgq5zz8gxv2l6prfbr7";

     

       150891
       150891
       -
              isLibrary = true;

     

       150892
       150892
       -
              isExecutable = true;

     

       150893
       150893
       -
              libraryHaskellDepends = [ base mtl parsec text ];

     

       150894
       150894
       -
              executableHaskellDepends = [ base text ];

     

       150895
       150895
       -
              testHaskellDepends = [ base parsec tasty tasty-hunit text ];

     

       150896
       150896
       -
              description = "Handle Jira wiki markup";

     

       150897
       150897
       -
              license = lib.licenses.mit;

     

       150898
       150898
       -
              hydraPlatforms = lib.platforms.none;

     

       150899
       150899
       -
            }) {};

     

       150900
       150900
       -
       

     

       150901
       150705
        
         "jmacro" = callPackage

     

       150902
       150706
        
           ({ mkDerivation, aeson, base, bytestring, containers

     

       150903
       150707
        
            , haskell-src-exts, haskell-src-meta, mtl, parseargs, parsec

     
···

       155429
       155233
        
            }:

     

       155430
       155234
        
            mkDerivation {

     

       155431
       155235
        
              pname = "kqueue";

     

       155432
       155432
       -
              version = "0.2.1";

     

       155433
       155433
       -
              sha256 = "0svrswcglipmm47lnqi41hcsn1gvkcniva6qajwqxrdr0wvvhgdi";

     

       155236
       155236
       +
              version = "0.2";

     

       155237
       155237
       +
              sha256 = "0sbkyq17i41kln7scrfc9kdzsbyb787z33kzpkdz2vrziapns33h";

     

       155238
       155238
       +
              revision = "3";

     

       155239
       155239
       +
              editedCabalFile = "17wanwn4pmh6z6v7ncg50q4sgg87lllld50wa5j5mmb07q4c3mj7";

     

       155434
       155240
        
              libraryHaskellDepends = [ base directory filepath mtl time unix ];

     

       155435
       155241
        
              libraryToolDepends = [ c2hs ];

     

       155436
       155242
        
              description = "A binding to the kqueue event library";

     
···

       161559
       161365
        
           ({ mkDerivation, base, bytestring, libtelnet }:

     

       161560
       161366
        
            mkDerivation {

     

       161561
       161367
        
              pname = "libtelnet";

     

       161562
       161562
       -
              version = "0.1.0.1";

     

       161563
       161563
       -
              sha256 = "13g7wpibjncj9h6yva8gj9fqs8j806r1vnina78wgv8f980dqxks";

     

       161368
       161368
       +
              version = "0.1.0.0";

     

       161369
       161369
       +
              sha256 = "0s2ldi4ikjdvki8r190mnkjd0jkahn8ln6gvqb8bn5d291j19nmc";

     

       161564
       161370
        
              isLibrary = true;

     

       161565
       161371
        
              isExecutable = true;

     

       161566
       161372
        
              libraryHaskellDepends = [ base bytestring ];

     
···

       166430
       166236
        
            }:

     

       166431
       166237
        
            mkDerivation {

     

       166432
       166238
        
              pname = "lsp";

     

       166433
       166433
       -
              version = "1.1.1.0";

     

       166434
       166434
       -
              sha256 = "04ndz4v1mwga13qndmnaaj145y5zqw7zv64px7ak26qvd1m26h9r";

     

       166239
       166239
       +
              version = "1.0.0.1";

     

       166240
       166240
       +
              sha256 = "1h7ymzzm00dnvbqxz4g0zp3mvm6v9bjbgkazz514wqrcmma27cm1";

     

       166435
       166241
        
              isLibrary = true;

     

       166436
       166242
        
              isExecutable = true;

     

       166437
       166243
        
              libraryHaskellDepends = [

     
···

       166505
       166311
        
              hydraPlatforms = lib.platforms.none;

     

       166506
       166312
        
            }) {};

     

       166507
       166313
        
       

     

       166508
       166508
       -
         "lsp-test_0_13_0_0" = callPackage

     

       166314
       166314
       +
         "lsp-test_0_12_0_0" = callPackage

     

       166509
       166315
        
           ({ mkDerivation, aeson, aeson-pretty, ansi-terminal, async, base

     

       166510
       166316
        
            , bytestring, conduit, conduit-parse, containers, data-default

     

       166511
       166511
       -
            , Diff, directory, filepath, Glob, hspec, lens, lsp-types, mtl

     

       166512
       166512
       -
            , parser-combinators, process, some, text, time, transformers, unix

     

       166317
       166317
       +
            , Diff, directory, filepath, Glob, haskell-lsp, hspec, lens, mtl

     

       166318
       166318
       +
            , parser-combinators, process, text, transformers, unix

     

       166513
       166319
        
            , unordered-containers

     

       166514
       166320
        
            }:

     

       166515
       166321
        
            mkDerivation {

     

       166516
       166322
        
              pname = "lsp-test";

     

       166517
       166517
       -
              version = "0.13.0.0";

     

       166518
       166518
       -
              sha256 = "1xyxmzcd6r56jj1k11lz1g6yld5q3k6cgb0bsf45px120dsf1dpy";

     

       166323
       166323
       +
              version = "0.12.0.0";

     

       166324
       166324
       +
              sha256 = "1zc43j7xyfxv2i9vinx82yhkrr6m4gz46jwn9p39k76ld6j8nzpd";

     

       166519
       166325
        
              isLibrary = true;

     

       166520
       166326
        
              isExecutable = true;

     

       166521
       166327
        
              libraryHaskellDepends = [

     

       166522
       166328
        
                aeson aeson-pretty ansi-terminal async base bytestring conduit

     

       166523
       166329
        
                conduit-parse containers data-default Diff directory filepath Glob

     

       166524
       166524
       -
                lens lsp-types mtl parser-combinators process some text time

     

       166525
       166525
       -
                transformers unix unordered-containers

     

       166330
       166330
       +
                haskell-lsp lens mtl parser-combinators process text transformers

     

       166331
       166331
       +
                unix unordered-containers

     

       166526
       166332
        
              ];

     

       166527
       166333
        
              testHaskellDepends = [

     

       166528
       166528
       -
                aeson base data-default directory filepath hspec lens lsp-types

     

       166334
       166334
       +
                aeson base data-default directory filepath haskell-lsp hspec lens

     

       166529
       166335
        
                text unordered-containers

     

       166530
       166336
        
              ];

     

       166531
       166337
        
              description = "Functional test framework for LSP servers";

     
···

       166535
       166341
        
       

     

       166536
       166342
        
         "lsp-types" = callPackage

     

       166537
       166343
        
           ({ mkDerivation, aeson, base, binary, bytestring, containers

     

       166538
       166538
       -
            , data-default, deepseq, dependent-sum, dependent-sum-template

     

       166539
       166539
       -
            , directory, filepath, hashable, hslogger, lens, network-uri

     

       166540
       166540
       -
            , rope-utf16-splay, scientific, some, template-haskell, temporary

     

       166541
       166541
       -
            , text, unordered-containers

     

       166344
       166344
       +
            , data-default, deepseq, dependent-sum-template, directory

     

       166345
       166345
       +
            , filepath, hashable, hslogger, lens, network-uri, rope-utf16-splay

     

       166346
       166346
       +
            , scientific, some, template-haskell, temporary, text

     

       166347
       166347
       +
            , unordered-containers

     

       166542
       166348
        
            }:

     

       166543
       166349
        
            mkDerivation {

     

       166544
       166350
        
              pname = "lsp-types";

     

       166545
       166545
       -
              version = "1.1.0.0";

     

       166546
       166546
       -
              sha256 = "19lkdqwh9a5rsx5nby37v54zhwyja306z0dyslsmdmwqw92qxx54";

     

       166351
       166351
       +
              version = "1.0.0.1";

     

       166352
       166352
       +
              sha256 = "1yrm42qsbqk94ql0khifcpvicy9lbvwwrvnr41lplbb1vhqvqc27";

     

       166547
       166353
        
              libraryHaskellDepends = [

     

       166548
       166354
        
                aeson base binary bytestring containers data-default deepseq

     

       166549
       166549
       -
                dependent-sum dependent-sum-template directory filepath hashable

     

       166550
       166550
       -
                hslogger lens network-uri rope-utf16-splay scientific some

     

       166551
       166551
       -
                template-haskell temporary text unordered-containers

     

       166355
       166355
       +
                dependent-sum-template directory filepath hashable hslogger lens

     

       166356
       166356
       +
                network-uri rope-utf16-splay scientific some template-haskell

     

       166357
       166357
       +
                temporary text unordered-containers

     

       166552
       166358
        
              ];

     

       166553
       166359
        
              description = "Haskell library for the Microsoft Language Server Protocol, data types";

     

       166554
       166360
        
              license = lib.licenses.mit;

     
···

       174814
       174620
        
            }) {};

     

       174815
       174621
        
       

     

       174816
       174622
        
         "mmsyn7l" = callPackage

     

       174817
       174817
       -
           ({ mkDerivation, base, directory, mmsyn2-array, mmsyn3

     

       174818
       174818
       -
            , mmsyn7ukr-common, process

     

       174623
       174623
       +
           ({ mkDerivation, base, directory, mmsyn2, mmsyn3, mmsyn7ukr

     

       174624
       174624
       +
            , process, vector

     

       174819
       174625
        
            }:

     

       174820
       174626
        
            mkDerivation {

     

       174821
       174627
        
              pname = "mmsyn7l";

     

       174822
       174822
       -
              version = "0.9.0.0";

     

       174823
       174823
       -
              sha256 = "0j8xi8jxak818sw310srxljrywggsa8ss1l4yw0razsa28h92nxq";

     

       174628
       174628
       +
              version = "0.8.0.0";

     

       174629
       174629
       +
              sha256 = "0w1k89phzxyq2nwzr0vn313rlp0f7d62vhdvq113pqszbdbjh6gd";

     

       174824
       174630
        
              isLibrary = true;

     

       174825
       174631
        
              isExecutable = true;

     

       174826
       174632
        
              libraryHaskellDepends = [

     

       174827
       174827
       -
                base directory mmsyn2-array mmsyn3 mmsyn7ukr-common process

     

       174633
       174633
       +
                base directory mmsyn2 mmsyn3 mmsyn7ukr process vector

     

       174828
       174634
        
              ];

     

       174829
       174635
        
              executableHaskellDepends = [

     

       174830
       174830
       -
                base directory mmsyn2-array mmsyn3 mmsyn7ukr-common process

     

       174636
       174636
       +
                base directory mmsyn2 mmsyn3 mmsyn7ukr process vector

     

       174831
       174637
        
              ];

     

       174832
       174638
        
              description = "Modifies the amplitudes of the Ukrainian sounds representations created by mmsyn7ukr package";

     

       174833
       174639
        
              license = lib.licenses.mit;

     
···

       175135
       174941
        
              license = lib.licenses.bsd3;

     

       175136
       174942
        
            }) {};

     

       175137
       174943
        
       

     

       175138
       175138
       -
         "modern-uri_0_3_4_0" = callPackage

     

       175139
       175139
       -
           ({ mkDerivation, base, bytestring, containers, contravariant

     

       175140
       175140
       -
            , criterion, deepseq, exceptions, hspec, hspec-discover

     

       175141
       175141
       -
            , hspec-megaparsec, megaparsec, mtl, profunctors, QuickCheck

     

       175142
       175142
       -
            , reflection, tagged, template-haskell, text, weigh

     

       175143
       175143
       -
            }:

     

       175144
       175144
       -
            mkDerivation {

     

       175145
       175145
       -
              pname = "modern-uri";

     

       175146
       175146
       -
              version = "0.3.4.0";

     

       175147
       175147
       -
              sha256 = "1jb1bj2jgxhhvkc50h1c11c3zd66bpbi67b1h6b8773h0yiqffvk";

     

       175148
       175148
       -
              libraryHaskellDepends = [

     

       175149
       175149
       -
                base bytestring containers contravariant deepseq exceptions

     

       175150
       175150
       -
                megaparsec mtl profunctors QuickCheck reflection tagged

     

       175151
       175151
       -
                template-haskell text

     

       175152
       175152
       -
              ];

     

       175153
       175153
       -
              testHaskellDepends = [

     

       175154
       175154
       -
                base bytestring hspec hspec-megaparsec megaparsec QuickCheck text

     

       175155
       175155
       -
              ];

     

       175156
       175156
       -
              testToolDepends = [ hspec-discover ];

     

       175157
       175157
       -
              benchmarkHaskellDepends = [

     

       175158
       175158
       -
                base bytestring criterion deepseq megaparsec text weigh

     

       175159
       175159
       -
              ];

     

       175160
       175160
       -
              description = "Modern library for working with URIs";

     

       175161
       175161
       -
              license = lib.licenses.bsd3;

     

       175162
       175162
       -
              hydraPlatforms = lib.platforms.none;

     

       175163
       175163
       -
            }) {};

     

       175164
       175164
       -
       

     

       175165
       174944
        
         "modify-fasta" = callPackage

     

       175166
       174945
        
           ({ mkDerivation, base, containers, fasta, mtl, optparse-applicative

     

       175167
       174946
        
            , pipes, pipes-text, regex-tdfa, regex-tdfa-text, semigroups, split

     
···

       179411
       179190
        
            }:

     

       179412
       179191
        
            mkDerivation {

     

       179413
       179192
        
              pname = "mu-rpc";

     

       179414
       179414
       -
              version = "0.5.0.1";

     

       179415
       179415
       -
              sha256 = "0r5kbi378iwg5b578dydvv4smy2xqn4y33h015fp5nyphxz83173";

     

       179193
       179193
       +
              version = "0.5.0.0";

     

       179194
       179194
       +
              sha256 = "15a950ig348h0fxfvzq4pj8s8rryn18cd26vmrcmx7s6w32zlzyr";

     

       179416
       179195
        
              libraryHaskellDepends = [

     

       179417
       179196
        
                aeson base conduit http-types mtl mu-schema sop-core

     

       179418
       179197
        
                template-haskell text wai

     
···

       181074
       180853
        
              pname = "mwc-random";

     

       181075
       180854
        
              version = "0.15.0.1";

     

       181076
       180855
        
              sha256 = "1p8c5g4hb72k90ai39rgpn6cr942i6636l1y0zfp9xgjb3v0a2q3";

     

       181077
       181077
       -
              revision = "1";

     

       181078
       181078
       -
              editedCabalFile = "1ay26mvzxqw6rzw3hkib1j12gk6fa2hsilz12q8vhp646bqqc744";

     

       181079
       180856
        
              libraryHaskellDepends = [

     

       181080
       180857
        
                base math-functions primitive random time vector

     

       181081
       180858
        
              ];

     
···

       183100
       182877
        
              ];

     

       183101
       182878
        
              description = "An MQTT Protocol Implementation";

     

       183102
       182879
        
              license = lib.licenses.bsd3;

     

       182880
       182880
       +
              hydraPlatforms = lib.platforms.none;

     

       182881
       182881
       +
              broken = true;

     

       183103
       182882
        
            }) {};

     

       183104
       182883
        
       

     

       183105
       182884
        
         "net-mqtt-lens" = callPackage

     
···

       183116
       182895
        
              ];

     

       183117
       182896
        
              description = "Optics for net-mqtt";

     

       183118
       182897
        
              license = lib.licenses.bsd3;

     

       182898
       182898
       +
              hydraPlatforms = lib.platforms.none;

     

       182899
       182899
       +
              broken = true;

     

       183119
       182900
        
            }) {};

     

       183120
       182901
        
       

     

       183121
       182902
        
         "net-mqtt-rpc" = callPackage

     
···

       183137
       182918
        
              ];

     

       183138
       182919
        
              description = "Make RPC calls via an MQTT broker";

     

       183139
       182920
        
              license = lib.licenses.bsd3;

     

       182921
       182921
       +
              hydraPlatforms = lib.platforms.none;

     

       182922
       182922
       +
              broken = true;

     

       183140
       182923
        
            }) {};

     

       183141
       182924
        
       

     

       183142
       182925
        
         "net-spider" = callPackage

     
···

       183965
       183748
        
              pname = "network-byte-order";

     

       183966
       183749
        
              version = "0.1.6";

     

       183967
       183750
        
              sha256 = "0pnwcg13k4qw82n0zc1xibyc24sc77y79j5a62pqdmjrnz4wrc7j";

     

       183968
       183968
       -
              revision = "1";

     

       183969
       183969
       -
              editedCabalFile = "0fpyfd1adg9fr7w6afxkx306c0kaz3ji3x78sl29v9j3mh4vdn13";

     

       183970
       183751
        
              libraryHaskellDepends = [ base bytestring ];

     

       183971
       183752
        
              testHaskellDepends = [ base bytestring doctest ];

     

       183972
       183753
        
              description = "Network byte order utilities";

     
···

       197082
       196863
        
              pname = "perfect-vector-shuffle";

     

       197083
       196864
        
              version = "0.1.1.1";

     

       197084
       196865
        
              sha256 = "1z4iv4sv9ld0gvdfa46ll5bsbxi9lckh69paip1c5ijcg78vy5y0";

     

       197085
       197085
       -
              revision = "5";

     

       197086
       197086
       -
              editedCabalFile = "0lppvhpfpfzcpdm4fxmsps8s272gz3wd2h5xc1w1908b7qqln0rw";

     

       196866
       196866
       +
              revision = "4";

     

       196867
       196867
       +
              editedCabalFile = "14q0773vxmkh4nwskiq85ch175jq12xms2lypaddglciykqs6ml6";

     

       197087
       196868
        
              isLibrary = true;

     

       197088
       196869
        
              isExecutable = true;

     

       197089
       196870
        
              libraryHaskellDepends = [

     
···

       198933
       198714
        
            }:

     

       198934
       198715
        
            mkDerivation {

     

       198935
       198716
        
              pname = "phonetic-languages-simplified-base";

     

       198936
       198936
       -
              version = "0.2.0.0";

     

       198937
       198937
       -
              sha256 = "1382i77ci70ax7lvbkqqvg1wr2pp5irl8wxvypngr15czqgj7sca";

     

       198717
       198717
       +
              version = "0.1.0.0";

     

       198718
       198718
       +
              sha256 = "0fd2pslmgm5bvv0yiza87vp61601pl1c69xa5snbgrnb2mlp6f98";

     

       198938
       198719
        
              libraryHaskellDepends = [

     

       198939
       198720
        
                base phonetic-languages-permutations-array subG

     

       198940
       198721
        
              ];

     
···

       200125
       199906
        
              license = lib.licenses.bsd3;

     

       200126
       199907
        
            }) {};

     

       200127
       199908
        
       

     

       200128
       200128
       -
         "pipes-bytestring_2_1_7" = callPackage

     

       200129
       200129
       -
           ({ mkDerivation, base, bytestring, pipes, pipes-group, pipes-parse

     

       200130
       200130
       -
            , stringsearch, transformers

     

       200131
       200131
       -
            }:

     

       200132
       200132
       -
            mkDerivation {

     

       200133
       200133
       -
              pname = "pipes-bytestring";

     

       200134
       200134
       -
              version = "2.1.7";

     

       200135
       200135
       -
              sha256 = "0ch7145pv4f56601ysdj5gqqwsh5ag2zh34ydswg62fqi8z8cxvc";

     

       200136
       200136
       -
              libraryHaskellDepends = [

     

       200137
       200137
       -
                base bytestring pipes pipes-group pipes-parse stringsearch

     

       200138
       200138
       -
                transformers

     

       200139
       200139
       -
              ];

     

       200140
       200140
       -
              description = "ByteString support for pipes";

     

       200141
       200141
       -
              license = lib.licenses.bsd3;

     

       200142
       200142
       -
              hydraPlatforms = lib.platforms.none;

     

       200143
       200143
       -
            }) {};

     

       200144
       200144
       -
       

     

       200145
       199909
        
         "pipes-bzip" = callPackage

     

       200146
       199910
        
           ({ mkDerivation, base, bindings-DSL, bytestring, bzip2, bzlib

     

       200147
       199911
        
            , data-default, directory, hspec, MonadRandom, mtl, pipes

     
···

       200802
       200566
        
              license = lib.licenses.bsd3;

     

       200803
       200567
        
            }) {};

     

       200804
       200568
        
       

     

       200805
       200805
       -
         "pipes-parse_3_0_9" = callPackage

     

       200806
       200806
       -
           ({ mkDerivation, base, pipes, transformers }:

     

       200807
       200807
       -
            mkDerivation {

     

       200808
       200808
       -
              pname = "pipes-parse";

     

       200809
       200809
       -
              version = "3.0.9";

     

       200810
       200810
       -
              sha256 = "05cd0j1avkzmryf3869hfpvd9xmzbpz4kc65srswx36n06dkz5x3";

     

       200811
       200811
       -
              libraryHaskellDepends = [ base pipes transformers ];

     

       200812
       200812
       -
              description = "Parsing infrastructure for the pipes ecosystem";

     

       200813
       200813
       -
              license = lib.licenses.bsd3;

     

       200814
       200814
       -
              hydraPlatforms = lib.platforms.none;

     

       200815
       200815
       -
            }) {};

     

       200816
       200816
       -
       

     

       200817
       200569
        
         "pipes-postgresql-simple" = callPackage

     

       200818
       200570
        
           ({ mkDerivation, async, base, bytestring, exceptions, mtl, pipes

     

       200819
       200571
        
            , pipes-concurrency, pipes-safe, postgresql-simple, stm, text

     
···

       200920
       200672
        
              ];

     

       200921
       200673
        
              description = "Safety for the pipes ecosystem";

     

       200922
       200674
        
              license = lib.licenses.bsd3;

     

       200923
       200923
       -
            }) {};

     

       200924
       200924
       -
       

     

       200925
       200925
       -
         "pipes-safe_2_3_3" = callPackage

     

       200926
       200926
       -
           ({ mkDerivation, base, containers, exceptions, monad-control, mtl

     

       200927
       200927
       -
            , pipes, primitive, transformers, transformers-base

     

       200928
       200928
       -
            }:

     

       200929
       200929
       -
            mkDerivation {

     

       200930
       200930
       -
              pname = "pipes-safe";

     

       200931
       200931
       -
              version = "2.3.3";

     

       200932
       200932
       -
              sha256 = "19gp93x5m1bnq240bj3v33pglf9r5gzji39fsjcazji837czghab";

     

       200933
       200933
       -
              libraryHaskellDepends = [

     

       200934
       200934
       -
                base containers exceptions monad-control mtl pipes primitive

     

       200935
       200935
       -
                transformers transformers-base

     

       200936
       200936
       -
              ];

     

       200937
       200937
       -
              description = "Safety for the pipes ecosystem";

     

       200938
       200938
       -
              license = lib.licenses.bsd3;

     

       200939
       200939
       -
              hydraPlatforms = lib.platforms.none;

     

       200940
       200675
        
            }) {};

     

       200941
       200676
        
       

     

       200942
       200677
        
         "pipes-shell" = callPackage

     
···

       201197
       200932
        
              license = lib.licenses.bsd3;

     

       201198
       200933
        
              hydraPlatforms = lib.platforms.none;

     

       201199
       200934
        
              broken = true;

     

       201200
       201200
       -
            }) {};

     

       201201
       201201
       -
       

     

       201202
       201202
       -
         "pixel-printer" = callPackage

     

       201203
       201203
       -
           ({ mkDerivation, base, JuicyPixels, lens }:

     

       201204
       201204
       -
            mkDerivation {

     

       201205
       201205
       -
              pname = "pixel-printer";

     

       201206
       201206
       -
              version = "0.1.0";

     

       201207
       201207
       -
              sha256 = "1cx485lvd5z6895jv1iiq93kspch78w9m730ggw6nvf0rimvazyy";

     

       201208
       201208
       -
              isLibrary = true;

     

       201209
       201209
       -
              isExecutable = true;

     

       201210
       201210
       -
              libraryHaskellDepends = [ base JuicyPixels lens ];

     

       201211
       201211
       -
              executableHaskellDepends = [ base JuicyPixels ];

     

       201212
       201212
       -
              testHaskellDepends = [ base ];

     

       201213
       201213
       -
              description = "A program for turning pixel art into 3D prints";

     

       201214
       201214
       -
              license = lib.licenses.gpl3;

     

       201215
       200935
        
            }) {};

     

       201216
       200936
        
       

     

       201217
       200937
        
         "pixela" = callPackage

     
···

       213653
       213373
        
              pname = "random";

     

       213654
       213374
        
              version = "1.2.0";

     

       213655
       213375
        
              sha256 = "1pmr7zbbqg58kihhhwj8figf5jdchhi7ik2apsyxbgsqq3vrqlg4";

     

       213656
       213656
       -
              revision = "5";

     

       213657
       213657
       -
              editedCabalFile = "1jai1pcs39ijdhxc8q36x1yayr8rsblhx3y88paf4bqxrks2vmrh";

     

       213376
       213376
       +
              revision = "4";

     

       213377
       213377
       +
              editedCabalFile = "08mq836ganl3sq6mfn3hrj6xm0h30klp21y7gbd9md2882agndrk";

     

       213658
       213378
        
              libraryHaskellDepends = [ base bytestring deepseq mtl splitmix ];

     

       213659
       213379
        
              testHaskellDepends = [

     

       213660
       213380
        
                base bytestring containers doctest mwc-random primitive smallcheck

     
···

       213719
       213439
        
              ];

     

       213720
       213440
        
              description = "Efficient generation of random bytestrings";

     

       213721
       213441
        
              license = lib.licenses.mit;

     

       213722
       213722
       -
            }) {};

     

       213723
       213723
       -
       

     

       213724
       213724
       -
         "random-bytestring_0_1_4" = callPackage

     

       213725
       213725
       -
           ({ mkDerivation, async, base, bytestring, criterion, cryptonite

     

       213726
       213726
       -
            , entropy, ghc-prim, mwc-random, pcg-random, primitive, random

     

       213727
       213727
       -
            }:

     

       213728
       213728
       -
            mkDerivation {

     

       213729
       213729
       -
              pname = "random-bytestring";

     

       213730
       213730
       -
              version = "0.1.4";

     

       213731
       213731
       -
              sha256 = "0f4n41gqxxggadysvx3vg2iq89z7i7692ccrfmiajq73lbp6y34j";

     

       213732
       213732
       -
              libraryHaskellDepends = [ base bytestring mwc-random pcg-random ];

     

       213733
       213733
       -
              benchmarkHaskellDepends = [

     

       213734
       213734
       -
                async base bytestring criterion cryptonite entropy ghc-prim

     

       213735
       213735
       -
                mwc-random pcg-random primitive random

     

       213736
       213736
       -
              ];

     

       213737
       213737
       -
              description = "Efficient generation of random bytestrings";

     

       213738
       213738
       -
              license = lib.licenses.mit;

     

       213739
       213739
       -
              hydraPlatforms = lib.platforms.none;

     

       213740
       213442
        
            }) {};

     

       213741
       213443
        
       

     

       213742
       213444
        
         "random-class" = callPackage

     
···

       221415
       221117
        
            }:

     

       221416
       221118
        
            mkDerivation {

     

       221417
       221119
        
              pname = "rhbzquery";

     

       221418
       221418
       -
              version = "0.4.3";

     

       221419
       221419
       -
              sha256 = "13brargymd1c9b0csaprj85qdqg98bzj3z2smbb0v66myj48v6fp";

     

       221120
       221120
       +
              version = "0.4.2";

     

       221121
       221121
       +
              sha256 = "1j9nxizi1wsgz5gamdn9izy4aq6ci41gbkvsw7bbpc8fnvv5gpd2";

     

       221420
       221122
        
              isLibrary = false;

     

       221421
       221123
        
              isExecutable = true;

     

       221422
       221124
        
              executableHaskellDepends = [

     
···

       225690
       225392
        
            , containers, crackNum, deepseq, directory, doctest, filepath

     

       225691
       225393
        
            , gauge, Glob, hlint, mtl, pretty, process, QuickCheck, random

     

       225692
       225394
        
            , silently, syb, tasty, tasty-golden, tasty-hunit, tasty-quickcheck

     

       225693
       225693
       -
            , template-haskell, text, time, transformers, uniplate, z3

     

       225395
       225395
       +
            , template-haskell, time, transformers, uniplate, z3

     

       225694
       225396
        
            }:

     

       225695
       225397
        
            mkDerivation {

     

       225696
       225398
        
              pname = "sbv";

     

       225697
       225697
       -
              version = "8.10";

     

       225698
       225698
       -
              sha256 = "1j9hy840dl78rr1ixhlz24wwymbpiv46hpz8i6dd0gngrfha09ji";

     

       225399
       225399
       +
              version = "8.9";

     

       225400
       225400
       +
              sha256 = "1h8bhi1pjlg0v16wwqcvil7gq98b6dn8ckzmrsgb8sc3qz0nxj51";

     

       225699
       225401
        
              enableSeparateDataOutput = true;

     

       225700
       225402
        
              libraryHaskellDepends = [

     

       225701
       225403
        
                array async base containers crackNum deepseq directory filepath mtl

     

       225702
       225702
       -
                pretty process QuickCheck random syb template-haskell text time

     

       225404
       225404
       +
                pretty process QuickCheck random syb template-haskell time

     

       225703
       225405
        
                transformers uniplate

     

       225704
       225406
        
              ];

     

       225705
       225407
        
              testHaskellDepends = [

     
···

       225710
       225412
        
              testSystemDepends = [ z3 ];

     

       225711
       225413
        
              benchmarkHaskellDepends = [

     

       225712
       225414
        
                base bench-show containers crackNum deepseq directory filepath

     

       225713
       225713
       -
                gauge mtl process random silently syb text time

     

       225415
       225415
       +
                gauge mtl process random silently syb time

     

       225714
       225416
        
              ];

     

       225715
       225417
        
              description = "SMT Based Verification: Symbolic Haskell theorem prover using SMT solving";

     

       225716
       225418
        
              license = lib.licenses.bsd3;

     
···

       232015
       231717
        
              license = lib.licenses.mit;

     

       232016
       231718
        
            }) {};

     

       232017
       231719
        
       

     

       232018
       232018
       -
         "serversession_1_0_2" = callPackage

     

       232019
       232019
       -
           ({ mkDerivation, aeson, base, base64-bytestring, bytestring

     

       232020
       232020
       -
            , containers, data-default, hashable, hspec, nonce, path-pieces

     

       232021
       232021
       -
            , persistent-test, QuickCheck, text, time, transformers

     

       232022
       232022
       -
            , unordered-containers

     

       232023
       232023
       -
            }:

     

       232024
       232024
       -
            mkDerivation {

     

       232025
       232025
       -
              pname = "serversession";

     

       232026
       232026
       -
              version = "1.0.2";

     

       232027
       232027
       -
              sha256 = "02ynhgq6gn5ddx2yd8ns8ay0rrhzln2h6jrmnwk7x1fqqfvzx0jf";

     

       232028
       232028
       -
              libraryHaskellDepends = [

     

       232029
       232029
       -
                aeson base base64-bytestring bytestring data-default hashable nonce

     

       232030
       232030
       -
                path-pieces persistent-test text time transformers

     

       232031
       232031
       -
                unordered-containers

     

       232032
       232032
       -
              ];

     

       232033
       232033
       -
              testHaskellDepends = [

     

       232034
       232034
       -
                aeson base base64-bytestring bytestring containers data-default

     

       232035
       232035
       -
                hspec nonce path-pieces QuickCheck text time transformers

     

       232036
       232036
       -
                unordered-containers

     

       232037
       232037
       -
              ];

     

       232038
       232038
       -
              description = "Secure, modular server-side sessions";

     

       232039
       232039
       -
              license = lib.licenses.mit;

     

       232040
       232040
       -
              hydraPlatforms = lib.platforms.none;

     

       232041
       232041
       -
            }) {};

     

       232042
       232042
       -
       

     

       232043
       231720
        
         "serversession-backend-acid-state" = callPackage

     

       232044
       231721
        
           ({ mkDerivation, acid-state, base, containers, hspec, mtl, safecopy

     

       232045
       231722
        
            , serversession, unordered-containers

     

       232046
       231723
        
            }:

     

       232047
       231724
        
            mkDerivation {

     

       232048
       231725
        
              pname = "serversession-backend-acid-state";

     

       232049
       232049
       -
              version = "1.0.4";

     

       232050
       232050
       -
              sha256 = "1mchxnkrpa6grp8h5iji40fyhya2lvb433yby4iymaaakzgjs19z";

     

       231726
       231726
       +
              version = "1.0.3";

     

       231727
       231727
       +
              sha256 = "1rkw5an7lwx05063caqjhvf449jxij2zrbymg64p600mngb1flq0";

     

       232051
       231728
        
              libraryHaskellDepends = [

     

       232052
       231729
        
                acid-state base containers mtl safecopy serversession

     

       232053
       231730
        
                unordered-containers

     
···

       232071
       231748
        
            }:

     

       232072
       231749
        
            mkDerivation {

     

       232073
       231750
        
              pname = "serversession-backend-persistent";

     

       232074
       232074
       -
              version = "1.0.5";

     

       232075
       232075
       -
              sha256 = "1mcaqafyr5x0v475j7rs2z4059jggzfj8rky66ls0mlvd9br91s0";

     

       231751
       231751
       +
              version = "1.0.4";

     

       231752
       231752
       +
              sha256 = "074pxfv1yj6ffxp4bg0ia20w7ikdja3g3k1l93nnjcni13zddwn7";

     

       232076
       231753
        
              libraryHaskellDepends = [

     

       232077
       231754
        
                aeson base base64-bytestring bytestring cereal path-pieces

     

       232078
       231755
        
                persistent serversession tagged text time transformers

     
···

       232097
       231774
        
            }:

     

       232098
       231775
        
            mkDerivation {

     

       232099
       231776
        
              pname = "serversession-backend-redis";

     

       232100
       232100
       -
              version = "1.0.4";

     

       232101
       232101
       -
              sha256 = "1rrz2p103271pyhdlbwim8vz91yl1qip0lagf74d277x74v9hyp5";

     

       231777
       231777
       +
              version = "1.0.3";

     

       231778
       231778
       +
              sha256 = "059nak15x4cbwmfbvfih6ndwa6i5jhcba22h9gz44f6s84vhljyf";

     

       232102
       231779
        
              libraryHaskellDepends = [

     

       232103
       231780
        
                base bytestring hedis path-pieces serversession tagged text time

     

       232104
       231781
        
                transformers unordered-containers

     
···

       234699
       234376
        
            }:

     

       234700
       234377
        
            mkDerivation {

     

       234701
       234378
        
              pname = "signable";

     

       234702
       234702
       -
              version = "0.3";

     

       234703
       234703
       -
              sha256 = "1bh4i93333s3yldn4nnl4xv4gb92ggdwap6im9f259cfg1v22d2q";

     

       234379
       234379
       +
              version = "0.2";

     

       234380
       234380
       +
              sha256 = "1p1g6jhxgskl890g84nw8d465pan9d3prbc4jvyn8502bx00w01s";

     

       234704
       234381
        
              libraryHaskellDepends = [

     

       234705
       234382
        
                asn1-encoding asn1-types base binary bytestring casing cryptonite

     

       234706
       234383
        
                memory microlens pem proto-lens proto-lens-runtime

     
···

       246453
       246130
        
              pname = "streamproc";

     

       246454
       246131
        
              version = "1.6.2";

     

       246455
       246132
        
              sha256 = "1wl44n4nav4h203mzfdf1bd5nh4v23dib54lvxka1rl3zymgyvp7";

     

       246456
       246456
       -
              revision = "2";

     

       246457
       246457
       -
              editedCabalFile = "1j3frdzhlvmggqq07b7kiz6h7mim64n2frsb2d3hzsjd7jym526j";

     

       246133
       246133
       +
              revision = "1";

     

       246134
       246134
       +
              editedCabalFile = "19c51gks028x8mnywkx1nz0s6bwn2mxs5ddmaj2q8n9l5pvfkcgs";

     

       246458
       246135
        
              libraryHaskellDepends = [ base ];

     

       246459
       246136
        
              description = "Stream Processer Arrow";

     

       246460
       246137
        
              license = lib.licenses.bsd3;

     
···

       246892
       246569
        
              license = lib.licenses.bsd3;

     

       246893
       246570
        
            }) {};

     

       246894
       246571
        
       

     

       246895
       246895
       -
         "string-interpolate_0_3_1_0" = callPackage

     

       246896
       246896
       -
           ({ mkDerivation, base, bytestring, criterion, deepseq, formatting

     

       246897
       246897
       -
            , haskell-src-exts, haskell-src-meta, hspec, hspec-core

     

       246898
       246898
       -
            , interpolate, neat-interpolation, QuickCheck, quickcheck-instances

     

       246899
       246899
       -
            , quickcheck-text, quickcheck-unicode, split, template-haskell

     

       246900
       246900
       -
            , text, text-conversions, unordered-containers, utf8-string

     

       246901
       246901
       -
            }:

     

       246902
       246902
       -
            mkDerivation {

     

       246903
       246903
       -
              pname = "string-interpolate";

     

       246904
       246904
       -
              version = "0.3.1.0";

     

       246905
       246905
       -
              sha256 = "0hyrcndhwd06phlmykyz7bklj5gnj4amcn11ckfvw0iws3sksl8d";

     

       246906
       246906
       -
              libraryHaskellDepends = [

     

       246907
       246907
       -
                base bytestring haskell-src-exts haskell-src-meta split

     

       246908
       246908
       -
                template-haskell text text-conversions utf8-string

     

       246909
       246909
       -
              ];

     

       246910
       246910
       -
              testHaskellDepends = [

     

       246911
       246911
       -
                base bytestring hspec hspec-core QuickCheck quickcheck-instances

     

       246912
       246912
       -
                quickcheck-text quickcheck-unicode template-haskell text

     

       246913
       246913
       -
                unordered-containers

     

       246914
       246914
       -
              ];

     

       246915
       246915
       -
              benchmarkHaskellDepends = [

     

       246916
       246916
       -
                base bytestring criterion deepseq formatting interpolate

     

       246917
       246917
       -
                neat-interpolation QuickCheck text

     

       246918
       246918
       -
              ];

     

       246919
       246919
       -
              description = "Haskell string/text/bytestring interpolation that just works";

     

       246920
       246920
       -
              license = lib.licenses.bsd3;

     

       246921
       246921
       -
              hydraPlatforms = lib.platforms.none;

     

       246922
       246922
       -
            }) {};

     

       246923
       246923
       -
       

     

       246924
       246572
        
         "string-isos" = callPackage

     

       246925
       246573
        
           ({ mkDerivation, base, bytestring, mono-traversable, safe, text

     

       246926
       246574
        
            , type-iso

     
···

       249317
       248965
        
              license = lib.licenses.gpl2;

     

       249318
       248966
        
              hydraPlatforms = lib.platforms.none;

     

       249319
       248967
        
              broken = true;

     

       249320
       249320
       -
            }) {};

     

       249321
       249321
       -
       

     

       249322
       249322
       -
         "swisstable" = callPackage

     

       249323
       249323
       -
           ({ mkDerivation, base, criterion, deepseq, hashable, hashtables

     

       249324
       249324
       -
            , primitive, QuickCheck, tasty, tasty-discover, tasty-hunit, vector

     

       249325
       249325
       -
            }:

     

       249326
       249326
       -
            mkDerivation {

     

       249327
       249327
       -
              pname = "swisstable";

     

       249328
       249328
       -
              version = "0.1.0.2";

     

       249329
       249329
       -
              sha256 = "0zffsavnxnwhzxgbwpqg38gnjywgfdk60hbg0wvpggk1zaw0ylr1";

     

       249330
       249330
       -
              libraryHaskellDepends = [ base hashable primitive vector ];

     

       249331
       249331
       -
              testHaskellDepends = [

     

       249332
       249332
       -
                base hashable primitive QuickCheck tasty tasty-discover tasty-hunit

     

       249333
       249333
       -
                vector

     

       249334
       249334
       -
              ];

     

       249335
       249335
       -
              testToolDepends = [ tasty-discover ];

     

       249336
       249336
       -
              benchmarkHaskellDepends = [

     

       249337
       249337
       -
                base criterion deepseq hashable hashtables primitive QuickCheck

     

       249338
       249338
       -
                vector

     

       249339
       249339
       -
              ];

     

       249340
       249340
       -
              description = "SwissTable hash map";

     

       249341
       249341
       -
              license = lib.licenses.bsd3;

     

       249342
       248968
        
            }) {};

     

       249343
       248969
        
       

     

       249344
       248970
        
         "sws" = callPackage

     
···

       257554
       257180
        
              pname = "these";

     

       257555
       257181
        
              version = "1.1.1.1";

     

       257556
       257182
        
              sha256 = "027m1gd7i6jf2ppfkld9qrv3xnxg276587pmx10z9phpdvswk66p";

     

       257557
       257557
       -
              revision = "1";

     

       257558
       257558
       -
              editedCabalFile = "1bzi28jvaxil9rc6z1hkf87pfjsa3r5gfc9n0ixffnnv519cd0g9";

     

       257559
       257183
        
              libraryHaskellDepends = [ assoc base binary deepseq hashable ];

     

       257560
       257184
        
              description = "An either-or-both data type";

     

       257561
       257185
        
              license = lib.licenses.bsd3;

     
···

       258576
       258200
        
              pname = "time-compat";

     

       258577
       258201
        
              version = "1.9.5";

     

       258578
       258202
        
              sha256 = "19p3056i6kh8lgcdsnwsh8pj80xyi23kmw9n7hmdacczs5kv49ii";

     

       258579
       258579
       -
              revision = "1";

     

       258580
       258580
       -
              editedCabalFile = "1f6r8cyfgzpfg9nrsqbf99pi44fyds9wcmgwxb4s0zmlb5dbv1m5";

     

       258581
       258203
        
              libraryHaskellDepends = [ base base-orphans deepseq time ];

     

       258582
       258204
        
              testHaskellDepends = [

     

       258583
       258205
        
                base base-compat deepseq HUnit QuickCheck tagged tasty tasty-hunit

     
···

       260554
       260176
        
              ];

     

       260555
       260177
        
              description = "Bidirectional TOML serialization";

     

       260556
       260178
        
              license = lib.licenses.mpl20;

     

       260557
       260557
       -
            }) {};

     

       260558
       260558
       -
       

     

       260559
       260559
       -
         "tomland_1_3_2_0" = callPackage

     

       260560
       260560
       -
           ({ mkDerivation, base, bytestring, containers, deepseq, directory

     

       260561
       260561
       -
            , hashable, hedgehog, hspec, hspec-golden, hspec-hedgehog

     

       260562
       260562
       -
            , hspec-megaparsec, markdown-unlit, megaparsec, mtl

     

       260563
       260563
       -
            , parser-combinators, text, time, transformers

     

       260564
       260564
       -
            , unordered-containers, validation-selective

     

       260565
       260565
       -
            }:

     

       260566
       260566
       -
            mkDerivation {

     

       260567
       260567
       -
              pname = "tomland";

     

       260568
       260568
       -
              version = "1.3.2.0";

     

       260569
       260569
       -
              sha256 = "0yj39mh4z3v3jqri38s3ylrglv657g3m7gqr2rz8ydlvx2draknc";

     

       260570
       260570
       -
              isLibrary = true;

     

       260571
       260571
       -
              isExecutable = true;

     

       260572
       260572
       -
              libraryHaskellDepends = [

     

       260573
       260573
       -
                base bytestring containers deepseq hashable megaparsec mtl

     

       260574
       260574
       -
                parser-combinators text time transformers unordered-containers

     

       260575
       260575
       -
                validation-selective

     

       260576
       260576
       -
              ];

     

       260577
       260577
       -
              executableHaskellDepends = [

     

       260578
       260578
       -
                base bytestring containers hashable text time unordered-containers

     

       260579
       260579
       -
              ];

     

       260580
       260580
       -
              executableToolDepends = [ markdown-unlit ];

     

       260581
       260581
       -
              testHaskellDepends = [

     

       260582
       260582
       -
                base bytestring containers directory hashable hedgehog hspec

     

       260583
       260583
       -
                hspec-golden hspec-hedgehog hspec-megaparsec megaparsec text time

     

       260584
       260584
       -
                unordered-containers

     

       260585
       260585
       -
              ];

     

       260586
       260586
       -
              description = "Bidirectional TOML serialization";

     

       260587
       260587
       -
              license = lib.licenses.mpl20;

     

       260588
       260588
       -
              hydraPlatforms = lib.platforms.none;

     

       260589
       260179
        
            }) {};

     

       260590
       260180
        
       

     

       260591
       260181
        
         "tomlcheck" = callPackage

     
···

       266212
       265802
        
              license = lib.licenses.bsd3;

     

       266213
       265803
        
            }) {};

     

       266214
       265804
        
       

     

       266215
       266215
       -
         "ua-parser_0_7_6_0" = callPackage

     

       266216
       266216
       -
           ({ mkDerivation, aeson, base, bytestring, criterion, data-default

     

       266217
       266217
       -
            , deepseq, file-embed, filepath, HUnit, pcre-light, tasty

     

       266218
       266218
       -
            , tasty-hunit, tasty-quickcheck, text, yaml

     

       266219
       266219
       -
            }:

     

       266220
       266220
       -
            mkDerivation {

     

       266221
       266221
       -
              pname = "ua-parser";

     

       266222
       266222
       -
              version = "0.7.6.0";

     

       266223
       266223
       -
              sha256 = "0sakvmmf6p2ca0dbkwqdj5cv93gp78srw0zc4f1skcgndkmxwk6l";

     

       266224
       266224
       -
              enableSeparateDataOutput = true;

     

       266225
       266225
       -
              libraryHaskellDepends = [

     

       266226
       266226
       -
                aeson base bytestring data-default file-embed pcre-light text yaml

     

       266227
       266227
       -
              ];

     

       266228
       266228
       -
              testHaskellDepends = [

     

       266229
       266229
       -
                aeson base bytestring data-default file-embed filepath HUnit

     

       266230
       266230
       -
                pcre-light tasty tasty-hunit tasty-quickcheck text yaml

     

       266231
       266231
       -
              ];

     

       266232
       266232
       -
              benchmarkHaskellDepends = [

     

       266233
       266233
       -
                aeson base bytestring criterion data-default deepseq file-embed

     

       266234
       266234
       -
                filepath pcre-light text yaml

     

       266235
       266235
       -
              ];

     

       266236
       266236
       -
              description = "A library for parsing User-Agent strings, official Haskell port of ua-parser";

     

       266237
       266237
       -
              license = lib.licenses.bsd3;

     

       266238
       266238
       -
              hydraPlatforms = lib.platforms.none;

     

       266239
       266239
       -
            }) {};

     

       266240
       266240
       -
       

     

       266241
       265805
        
         "uacpid" = callPackage

     

       266242
       265806
        
           ({ mkDerivation, base, containers, directory, filepath, hslogger

     

       266243
       265807
        
            , mtl, network, process, regex-compat, time, time-locale-compat

     
···

       270230
       269794
        
              pname = "uuid";

     

       270231
       269795
        
              version = "1.3.13";

     

       270232
       269796
        
              sha256 = "09xhk42yhxvqmka0iqrv3338asncz8cap3j0ic0ps896f2581b6z";

     

       270233
       270233
       -
              revision = "5";

     

       270234
       270234
       -
              editedCabalFile = "0hv9xrs6n005cid9laxbimyg5cxywvcd0fh8pyadqqvk3b8zlj9d";

     

       269797
       269797
       +
              revision = "3";

     

       269798
       269798
       +
              editedCabalFile = "1p2srrapgx1f3zkdjjzm5g0dyfpg1h2g056la85xmpyjs77la2rq";

     

       270235
       269799
        
              libraryHaskellDepends = [

     

       270236
       269800
        
                base binary bytestring cryptohash-md5 cryptohash-sha1 entropy

     

       270237
       269801
        
                network-info random text time uuid-types

     
···

       270350
       269914
        
              pname = "uuid-types";

     

       270351
       269915
        
              version = "1.0.3";

     

       270352
       269916
        
              sha256 = "1zdka5jnm1h6k36w3nr647yf3b5lqb336g3fkprhd6san9x52xlj";

     

       270353
       270353
       -
              revision = "4";

     

       270354
       270354
       -
              editedCabalFile = "0ipwfd5y8021ygpadjjhchw5irm0x27dlv1k2hf4znza5v7hadcn";

     

       269917
       269917
       +
              revision = "3";

     

       269918
       269918
       +
              editedCabalFile = "0znx08r25sgs5j7ix8i9aikhgad0kc9i6vgkg0g3jzxk5haal9sf";

     

       270355
       269919
        
              libraryHaskellDepends = [

     

       270356
       269920
        
                base binary bytestring deepseq hashable random text

     

       270357
       269921
        
              ];

     
···

       272045
       271609
        
            }:

     

       272046
       271610
        
            mkDerivation {

     

       272047
       271611
        
              pname = "vega-view";

     

       272048
       272048
       -
              version = "0.3.1.7";

     

       272049
       272049
       -
              sha256 = "1181gfxyxf2m3m23xg89kmmp8aizrm9sm908ydbkw885idh2k5x0";

     

       271612
       271612
       +
              version = "0.3.1.6";

     

       271613
       271613
       +
              sha256 = "0s9d3g47qnzcpi2p1z60axrr53jbc6q4qyma88qxsrf6ava115ar";

     

       272050
       271614
        
              isLibrary = false;

     

       272051
       271615
        
              isExecutable = true;

     

       272052
       271616
        
              executableHaskellDepends = [

     
···

       283274
       282838
        
              hydraPlatforms = lib.platforms.none;

     

       283275
       282839
        
              broken = true;

     

       283276
       282840
        
            }) {inherit (pkgs) libdevil;};

     

       283277
       283277
       -
       

     

       283278
       283278
       -
         "yasi" = callPackage

     

       283279
       283279
       -
           ({ mkDerivation, base, bytestring, hedgehog, tasty, tasty-discover

     

       283280
       283280
       -
            , tasty-hedgehog, tasty-hunit, template-haskell, text

     

       283281
       283281
       -
            }:

     

       283282
       283282
       -
            mkDerivation {

     

       283283
       283283
       -
              pname = "yasi";

     

       283284
       283284
       -
              version = "0.1.1.1";

     

       283285
       283285
       -
              sha256 = "0b3ajgxf8bk2pjfwqmf748x1yzyq9knjsya2xzkdrjs5vffg1j9k";

     

       283286
       283286
       -
              libraryHaskellDepends = [ base bytestring template-haskell text ];

     

       283287
       283287
       -
              testHaskellDepends = [

     

       283288
       283288
       -
                base hedgehog tasty tasty-hedgehog tasty-hunit text

     

       283289
       283289
       -
              ];

     

       283290
       283290
       -
              testToolDepends = [ tasty-discover ];

     

       283291
       283291
       -
              description = "Yet another string interpolator";

     

       283292
       283292
       -
              license = lib.licenses.cc0;

     

       283293
       283293
       -
            }) {};

     

       283294
       282841
        
       

     

       283295
       282842
        
         "yate" = callPackage

     

       283296
       282843
        
           ({ mkDerivation, aeson, attoparsec, base, hspec, mtl, scientific

+2 -2

pkgs/development/interpreters/janet/default.nix

···

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation rec {

     

       4
       4
        
         pname = "janet";

     

       5
       5
       -
         version = "1.15.0";

     

       5
       5
       +
         version = "1.15.2";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "janet-lang";

     

       9
       9
        
           repo = pname;

     

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

     

       11
       11
       -
           sha256 = "sha256-NLPmuS7HTPY8OfeppqVhrj4iVZix4orr1oYilcXaAqI=";

     

       11
       11
       +
           sha256 = "sha256-xIvcHMDBPdmNSp0/aaVDXxCmCpQOtSFG99lyHAWmbY0=";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         nativeBuildInputs = [ meson ninja ];

+2 -5

pkgs/development/interpreters/quickjs/default.nix

···

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation rec {

     

       4
       4
        
         pname = "quickjs";

     

       5
       5
       -
         version = "2019-12-21";

     

       5
       5
       +
         version = "2020-11-08";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchurl {

     

       8
       8
        
           url = "https://bellard.org/${pname}/${pname}-${version}.tar.xz";

     

       9
       9
       -
           sha256 = "13hlx6qwrrxmlvvqcr3irxba6zmf05cf54l32vj50wc66s1qd41p";

     

       9
       9
       +
           sha256 = "0yqqcjxi3cqagw184mqrxpvqg486x7c233r3cp9mxachngd6779f";

     

       10
       10
        
         };

     

       11
       11
        
       

     

       12
       12
        
         makeFlags = [ "prefix=${placeholder "out"}" ];

     
···

       19
       19
        
           # Programs exit with code 1 when testing help, so grep for a string

     

       20
       20
        
           set +o pipefail

     

       21
       21
        
           qjs     --help 2>&1 | grep "QuickJS version"

     

       22
       22
       -
           qjsbn   --help 2>&1 | grep "QuickJS version"

     

       23
       22
        
           qjscalc --help 2>&1 | grep "QuickJS version"

     

       24
       23
        
           set -o pipefail

     

       25
       24
        
       

     
···

       27
       26
        
           echo "console.log('Output from compiled program');" > "$temp"

     

       28
       27
        
           set -o verbose

     

       29
       28
        
           out=$(mktemp) && qjsc         "$temp" -o "$out" && "$out" | grep -q "Output from compiled program"

     

       30
       30
       -
           out=$(mktemp) && qjsbnc       "$temp" -o "$out" && "$out" | grep -q "Output from compiled program"

     

       31
       29
        
           out=$(mktemp) && qjsc   -flto "$temp" -o "$out" && "$out" | grep -q "Output from compiled program"

     

       32
       32
       -
           out=$(mktemp) && qjsbnc -flto "$temp" -o "$out" && "$out" | grep -q "Output from compiled program"

     

       33
       30
        
         '';

     

       34
       31
        
       

     

       35
       32
        
         meta = with lib; {

+1 -30

pkgs/development/libraries/science/math/cudnn/default.nix

···

       1
       1
       -
       { callPackage, cudatoolkit_7, cudatoolkit_7_5, cudatoolkit_8, cudatoolkit_9_0, cudatoolkit_9_1, cudatoolkit_9_2, cudatoolkit_10_0, cudatoolkit_10_1, cudatoolkit_10_2, cudatoolkit_11_0, cudatoolkit_11_1, cudatoolkit_11_2 }:

     

       1
       1
       +
       { callPackage, cudatoolkit_9_0, cudatoolkit_9_1, cudatoolkit_9_2, cudatoolkit_10_0, cudatoolkit_10_1, cudatoolkit_10_2, cudatoolkit_11_0, cudatoolkit_11_1, cudatoolkit_11_2 }:

     

       2
       2
        
       

     

       3
       3
        
       let

     

       4
       4
        
         generic = args: callPackage (import ./generic.nix (removeAttrs args ["cudatoolkit"])) {

     
···

       6
       6
        
         };

     

       7
       7
        
       

     

       8
       8
        
       in rec {

     

       9
       9
       -
         cudnn_cudatoolkit_7 = generic rec {

     

       10
       10
       -
           # Old URL is v4 instead of v4.0 for some reason...

     

       11
       11
       -
           version = "4";

     

       12
       12
       -
           cudatoolkit = cudatoolkit_7;

     

       13
       13
       -
           srcName = "cudnn-${cudatoolkit.majorVersion}-linux-x64-v4.0-prod.tgz";

     

       14
       14
       -
           sha256 = "01a4v5j4v9n2xjqcc4m28c3m67qrvsx87npvy7zhx7w8smiif2fd";

     

       15
       15
       -
         };

     

       16
       16
       -
       

     

       17
       17
       -
         cudnn_cudatoolkit_7_5 = generic rec {

     

       18
       18
       -
           version = "6.0";

     

       19
       19
       -
           cudatoolkit = cudatoolkit_7_5;

     

       20
       20
       -
           srcName = "cudnn-${cudatoolkit.majorVersion}-linux-x64-v${version}.tgz";

     

       21
       21
       -
           sha256 = "0b68hv8pqcvh7z8xlgm4cxr9rfbjs0yvg1xj2n5ap4az1h3lp3an";

     

       22
       22
       -
         };

     

       23
       23
       -
       

     

       24
       24
       -
         cudnn6_cudatoolkit_8 = generic rec {

     

       25
       25
       -
           version = "6.0";

     

       26
       26
       -
           cudatoolkit = cudatoolkit_8;

     

       27
       27
       -
           srcName = "cudnn-${cudatoolkit.majorVersion}-linux-x64-v${version}.tgz";

     

       28
       28
       -
           sha256 = "173zpgrk55ri8if7s5yngsc89ajd6hz4pss4cdxlv6lcyh5122cv";

     

       29
       29
       -
         };

     

       30
       30
       -
       

     

       31
       31
       -
         cudnn_cudatoolkit_8 = generic rec {

     

       32
       32
       -
           version = "7.0.5";

     

       33
       33
       -
           cudatoolkit = cudatoolkit_8;

     

       34
       34
       -
           srcName = "cudnn-${cudatoolkit.majorVersion}-linux-x64-v7.tgz";

     

       35
       35
       -
           sha256 = "9e0b31735918fe33a79c4b3e612143d33f48f61c095a3b993023cdab46f6d66e";

     

       36
       36
       -
         };

     

       37
       37
       -
       

     

       38
       9
        
         cudnn_cudatoolkit_9_0 = generic rec {

     

       39
       10
        
           version = "7.3.0";

     

       40
       11
        
           cudatoolkit = cudatoolkit_9_0;

+7 -2

pkgs/development/node-packages/generate.sh

···

       2
       2
        
       set -eu -o pipefail

     

       3
       3
        
       

     

       4
       4
        
       DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"

     

       5
       5
       -
       node2nix=$(nix-build ../../.. --no-out-link -A nodePackages.node2nix)

     

       6
       6
       -
       

     

       5
       5
       +
       node2nix=$(nix-build ../../.. -A nodePackages.node2nix)

     

       7
       6
        
       cd ${DIR}

     

       8
       7
        
       rm -f ./node-env.nix

     

       9
       8
        
       ${node2nix}/bin/node2nix -i node-packages.json -o node-packages.nix -c composition.nix

     

       9
       9
       +
       # using --no-out-link in nix-build argument would cause the

     

       10
       10
       +
       # gc to run before the script finishes

     

       11
       11
       +
       # which would cause a failure

     

       12
       12
       +
       # it's safer to just remove the link after the script finishes

     

       13
       13
       +
       # see https://github.com/NixOS/nixpkgs/issues/112846 for more details

     

       14
       14
       +
       rm ./result

+66

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

···

       1
       1
       +
       { lib, buildDunePackage, fetchurl

     

       2
       2
       +
       , ke, duff, decompress, cstruct, optint, bigstringaf, stdlib-shims

     

       3
       3
       +
       , bigarray-compat, checkseum, logs, psq, fmt

     

       4
       4
       +
       , result, rresult, fpath, base64, bos, digestif, mmap, alcotest

     

       5
       5
       +
       , crowbar, alcotest-lwt, lwt, findlib, mirage-flow, cmdliner

     

       6
       6
       +
       }:

     

       7
       7
       +
       

     

       8
       8
       +
       buildDunePackage rec {

     

       9
       9
       +
         pname = "carton";

     

       10
       10
       +
         version = "0.2.0";

     

       11
       11
       +
       

     

       12
       12
       +
         useDune2 = true;

     

       13
       13
       +
         minimumOCamlVersion = "4.08";

     

       14
       14
       +
       

     

       15
       15
       +
         src = fetchurl {

     

       16
       16
       +
           url = "https://github.com/mirage/ocaml-git/releases/download/${pname}-v${version}/${pname}-${pname}-v${version}.tbz";

     

       17
       17
       +
           sha256 = "0gfns4a9p9540kijccsg52yzyn3jfvi737mb0g71yazyc89dqwhn";

     

       18
       18
       +
         };

     

       19
       19
       +
       

     

       20
       20
       +
         # remove changelogs for mimic and the git* packages

     

       21
       21
       +
         postPatch = ''

     

       22
       22
       +
           rm CHANGES.md CHANGES.mimic.md

     

       23
       23
       +
         '';

     

       24
       24
       +
       

     

       25
       25
       +
         buildInputs = [

     

       26
       26
       +
           cmdliner

     

       27
       27
       +
           digestif

     

       28
       28
       +
           mmap

     

       29
       29
       +
           result

     

       30
       30
       +
           rresult

     

       31
       31
       +
           fpath

     

       32
       32
       +
           bos

     

       33
       33
       +
         ];

     

       34
       34
       +
         propagatedBuildInputs = [

     

       35
       35
       +
           ke

     

       36
       36
       +
           duff

     

       37
       37
       +
           decompress

     

       38
       38
       +
           cstruct

     

       39
       39
       +
           optint

     

       40
       40
       +
           bigstringaf

     

       41
       41
       +
           stdlib-shims

     

       42
       42
       +
           bigarray-compat

     

       43
       43
       +
           checkseum

     

       44
       44
       +
           logs

     

       45
       45
       +
           psq

     

       46
       46
       +
           fmt

     

       47
       47
       +
         ];

     

       48
       48
       +
       

     

       49
       49
       +
         doCheck = true;

     

       50
       50
       +
         checkInputs = [

     

       51
       51
       +
           base64

     

       52
       52
       +
           alcotest

     

       53
       53
       +
           alcotest-lwt

     

       54
       54
       +
           crowbar

     

       55
       55
       +
           lwt

     

       56
       56
       +
           findlib

     

       57
       57
       +
           mirage-flow

     

       58
       58
       +
         ];

     

       59
       59
       +
       

     

       60
       60
       +
         meta = with lib; {

     

       61
       61
       +
           description = "Implementation of PACKv2 file in OCaml";

     

       62
       62
       +
           license = licenses.mit;

     

       63
       63
       +
           homepage = "https://github.com/mirage/ocaml-git";

     

       64
       64
       +
           maintainers = [ maintainers.sternenseemann ];

     

       65
       65
       +
         };

     

       66
       66
       +
       }

+28

pkgs/development/ocaml-modules/carton/git.nix

···

       1
       1
       +
       { buildDunePackage, carton, carton-lwt

     

       2
       2
       +
       , bigarray-compat, bigstringaf, lwt, fpath, result

     

       3
       3
       +
       , mmap, fmt, decompress, astring

     

       4
       4
       +
       , alcotest, alcotest-lwt, cstruct, logs

     

       5
       5
       +
       , mirage-flow, rresult, ke

     

       6
       6
       +
       }:

     

       7
       7
       +
       

     

       8
       8
       +
       buildDunePackage {

     

       9
       9
       +
         pname = "carton-git";

     

       10
       10
       +
       

     

       11
       11
       +
         inherit (carton) version src useDune2 minimumOCamlVersion postPatch;

     

       12
       12
       +
       

     

       13
       13
       +
         propagatedBuildInputs = [

     

       14
       14
       +
           carton

     

       15
       15
       +
           carton-lwt

     

       16
       16
       +
           bigarray-compat

     

       17
       17
       +
           bigstringaf

     

       18
       18
       +
           lwt

     

       19
       19
       +
           fpath

     

       20
       20
       +
           result

     

       21
       21
       +
           mmap

     

       22
       22
       +
           fmt

     

       23
       23
       +
           decompress

     

       24
       24
       +
           astring

     

       25
       25
       +
         ];

     

       26
       26
       +
       

     

       27
       27
       +
         inherit (carton) meta;

     

       28
       28
       +
       }

+46

pkgs/development/ocaml-modules/carton/lwt.nix

···

       1
       1
       +
       { buildDunePackage, carton

     

       2
       2
       +
       , lwt, decompress, optint, bigstringaf

     

       3
       3
       +
       , alcotest, alcotest-lwt, cstruct, fmt, logs

     

       4
       4
       +
       , mirage-flow, result, rresult, bigarray-compat

     

       5
       5
       +
       , ke, base64, bos, checkseum, digestif, fpath, mmap

     

       6
       6
       +
       , stdlib-shims

     

       7
       7
       +
       , git-binary # pkgs.git

     

       8
       8
       +
       }:

     

       9
       9
       +
       

     

       10
       10
       +
       buildDunePackage {

     

       11
       11
       +
         pname = "carton-lwt";

     

       12
       12
       +
       

     

       13
       13
       +
         inherit (carton) version src useDune2 minimumOCamlVersion postPatch;

     

       14
       14
       +
       

     

       15
       15
       +
         propagatedBuildInputs = [

     

       16
       16
       +
           carton

     

       17
       17
       +
           lwt

     

       18
       18
       +
           decompress

     

       19
       19
       +
           optint

     

       20
       20
       +
           bigstringaf

     

       21
       21
       +
         ];

     

       22
       22
       +
       

     

       23
       23
       +
         doCheck = true;

     

       24
       24
       +
         checkInputs = [

     

       25
       25
       +
           git-binary

     

       26
       26
       +
           alcotest

     

       27
       27
       +
           alcotest-lwt

     

       28
       28
       +
           cstruct

     

       29
       29
       +
           fmt

     

       30
       30
       +
           logs

     

       31
       31
       +
           mirage-flow

     

       32
       32
       +
           result

     

       33
       33
       +
           rresult

     

       34
       34
       +
           bigarray-compat

     

       35
       35
       +
           ke

     

       36
       36
       +
           base64

     

       37
       37
       +
           bos

     

       38
       38
       +
           checkseum

     

       39
       39
       +
           digestif

     

       40
       40
       +
           fpath

     

       41
       41
       +
           mmap

     

       42
       42
       +
           stdlib-shims

     

       43
       43
       +
         ];

     

       44
       44
       +
       

     

       45
       45
       +
         inherit (carton) meta;

     

       46
       46
       +
       }

+8 -7

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

···

       1
       1
        
       { lib, fetchurl, buildDunePackage

     

       2
       2
       -
       , checkseum, cmdliner

     

       3
       3
       -
       , alcotest, bos, camlzip, mmap, re

     

       2
       2
       +
       , checkseum, bigarray-compat, optint

     

       3
       3
       +
       , bigstringaf, alcotest, hxd, camlzip, base64

     

       4
       4
        
       }:

     

       5
       5
        
       

     

       6
       6
        
       buildDunePackage rec {

     

       7
       7
       -
         version = "0.9.0";

     

       7
       7
       +
         version = "1.2.0";

     

       8
       8
        
         pname = "decompress";

     

       9
       9
       +
       

     

       10
       10
       +
         minimumOCamlVersion = "4.07";

     

       9
       11
        
       

     

       10
       12
        
         useDune2 = true;

     

       11
       13
        
       

     

       12
       14
        
         src = fetchurl {

     

       13
       15
        
           url = "https://github.com/mirage/decompress/releases/download/v${version}/decompress-v${version}.tbz";

     

       14
       14
       -
           sha256 = "0fryhcvv96vfca51c7kqdn3n3canqsbbvfbi75ya6lca4lmpipbh";

     

       16
       16
       +
           sha256 = "1c3sq9a6kpzl0pj3gmg7w18ssjjl70yv0r3l7qjprcncjx23v62i";

     

       15
       17
        
         };

     

       16
       18
        
       

     

       17
       17
       -
         buildInputs = [ cmdliner ];

     

       18
       18
       -
         propagatedBuildInputs = [ checkseum ];

     

       19
       19
       -
         checkInputs = lib.optionals doCheck [ alcotest bos camlzip mmap re ];

     

       19
       19
       +
         propagatedBuildInputs = [ optint bigarray-compat checkseum ];

     

       20
       20
       +
         checkInputs = [ alcotest bigstringaf hxd camlzip base64 ];

     

       20
       21
        
         doCheck = true;

     

       21
       22
        
       

     

       22
       23
        
         meta = {

+12 -7

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

···

       1
       1
        
       { lib, fetchurl, buildDunePackage

     

       2
       2
       -
       , cstruct, fmt

     

       3
       3
       -
       , bos, cmdliner, fpath, logs

     

       4
       4
       -
       , alcotest

     

       2
       2
       +
       , stdlib-shims, bigarray-compat, fmt

     

       3
       3
       +
       , alcotest, hxd, crowbar, bigstringaf

     

       5
       4
        
       }:

     

       6
       5
        
       

     

       7
       6
        
       buildDunePackage rec {

     

       8
       7
        
         pname = "duff";

     

       9
       9
       -
         version = "0.2";

     

       8
       8
       +
         version = "0.3";

     

       10
       9
        
       

     

       11
       10
        
         useDune2 = true;

     

       12
       11
        
       

     

       13
       12
        
         src = fetchurl {

     

       14
       13
        
           url = "https://github.com/mirage/duff/releases/download/v${version}/duff-v${version}.tbz";

     

       15
       15
       -
           sha256 = "0bi081w4349cqc1n9jsjh1lrcqlnv3nycmvh9fniscv8lz1c0gjq";

     

       14
       14
       +
           sha256 = "1lb67yxk93ifj94p1i3swjbnj5xy8j6xzs72bwvq6cffx5xykznm";

     

       16
       15
        
         };

     

       17
       16
        
       

     

       18
       18
       -
         buildInputs = [ bos cmdliner fpath logs ] ++ lib.optional doCheck alcotest;

     

       19
       19
       -
         propagatedBuildInputs = [ cstruct fmt ];

     

       17
       17
       +
         propagatedBuildInputs = [ stdlib-shims bigarray-compat fmt ];

     

       20
       18
        
       

     

       21
       19
        
         doCheck = true;

     

       20
       20
       +
         checkInputs = [

     

       21
       21
       +
           alcotest

     

       22
       22
       +
           crowbar

     

       23
       23
       +
           hxd

     

       24
       24
       +
           bigstringaf

     

       25
       25
       +
         ];

     

       26
       26
       +
       

     

       22
       27
        
       

     

       23
       28
        
         meta = {

     

       24
       29
        
           description = "Pure OCaml implementation of libXdiff (Rabin’s fingerprint)";

+6 -5

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

···

       1
       1
        
       { lib, buildDunePackage, fetchurl, ocaml

     

       2
       2
       -
       , fmt, bigstringaf, bigarray-compat

     

       3
       3
       -
       , bigarray-overlap, angstrom, ke, alcotest }:

     

       2
       2
       +
       , fmt, bigstringaf, angstrom, alcotest }:

     

       4
       3
        
       

     

       5
       4
        
       buildDunePackage rec {

     

       6
       5
        
         pname = "encore";

     

       7
       7
       -
         version = "0.5";

     

       6
       6
       +
         version = "0.7";

     

       7
       7
       +
       

     

       8
       8
       +
         minimumOCamlVersion = "4.07";

     

       8
       9
        
       

     

       9
       10
        
         src = fetchurl {

     

       10
       11
        
           url = "https://github.com/mirage/encore/releases/download/v${version}/encore-v${version}.tbz";

     

       11
       11
       -
           sha256 = "15n0dla149k9h7migs76wap08z5402qcvxyqxzl887ha6isj3p9n";

     

       12
       12
       +
           sha256 = "0cwmhkj5jmk3z5y0agmkf5ygpgxynjkq2d7d50jgzmnqs7f6g7nh";

     

       12
       13
        
         };

     

       13
       14
        
       

     

       14
       15
        
         useDune2 = true;

     

       15
       16
        
       

     

       16
       16
       -
         propagatedBuildInputs = [ angstrom ke fmt bigstringaf bigarray-compat bigarray-overlap ];

     

       17
       17
       +
         propagatedBuildInputs = [ angstrom fmt bigstringaf ];

     

       17
       18
        
         checkInputs = [ alcotest ];

     

       18
       19
        
         doCheck = true;

     

       19
       20

-15

pkgs/development/ocaml-modules/git-http/default.nix

···

       1
       1
       -
       { buildDunePackage, git, cohttp, cohttp-lwt }:

     

       2
       2
       -
       

     

       3
       3
       -
       buildDunePackage {

     

       4
       4
       -
         pname = "git-http";

     

       5
       5
       -
         inherit (git) version src minimumOCamlVersion;

     

       6
       6
       -
       

     

       7
       7
       -
         useDune2 = true;

     

       8
       8
       -
       

     

       9
       9
       -
         propagatedBuildInputs = [ git cohttp cohttp-lwt ];

     

       10
       10
       -
       

     

       11
       11
       -
         meta = {

     

       12
       12
       -
           description = "Client implementation of the “Smart” HTTP Git protocol in pure OCaml";

     

       13
       13
       -
           inherit (git.meta) homepage license maintainers;

     

       14
       14
       -
         };

     

       15
       15
       -
       }

-20

pkgs/development/ocaml-modules/git-unix/default.nix

···

       1
       1
       -
       { stdenv, buildDunePackage, git-http, cohttp, cohttp-lwt-unix

     

       2
       2
       -
       , mmap, cmdliner, mtime, alcotest, mirage-crypto-rng, tls

     

       3
       3
       -
       , io-page, git-binary

     

       4
       4
       -
       }:

     

       5
       5
       -
       

     

       6
       6
       -
       buildDunePackage {

     

       7
       7
       -
         pname = "git-unix";

     

       8
       8
       -
         inherit (git-http) version src minimumOCamlVersion;

     

       9
       9
       -
       

     

       10
       10
       -
         useDune2 = true;

     

       11
       11
       -
       

     

       12
       12
       -
         propagatedBuildInputs = [ mmap cmdliner git-http cohttp cohttp-lwt-unix mtime ];

     

       13
       13
       -
         checkInputs = [ alcotest mirage-crypto-rng tls io-page git-binary ];

     

       14
       14
       -
         doCheck = !stdenv.isAarch64;

     

       15
       15
       -
       

     

       16
       16
       -
         meta = {

     

       17
       17
       -
           description = "Unix backend for the Git protocol(s)";

     

       18
       18
       -
           inherit (git-http.meta) homepage license maintainers;

     

       19
       19
       -
         };

     

       20
       20
       -
       }

+18

pkgs/development/ocaml-modules/git/cohttp-mirage.nix

···

       1
       1
       +
       { lib, buildDunePackage

     

       2
       2
       +
       , git, mimic, cohttp-mirage, cohttp, cohttp-lwt

     

       3
       3
       +
       , fmt, lwt, result, rresult, uri

     

       4
       4
       +
       }:

     

       5
       5
       +
       

     

       6
       6
       +
       buildDunePackage {

     

       7
       7
       +
         pname = "git-cohttp-mirage";

     

       8
       8
       +
       

     

       9
       9
       +
         inherit (git) version src minimumOCamlVersion useDune2;

     

       10
       10
       +
       

     

       11
       11
       +
         propagatedBuildInputs = [

     

       12
       12
       +
           git mimic cohttp-mirage cohttp cohttp-lwt fmt lwt result rresult uri

     

       13
       13
       +
         ];

     

       14
       14
       +
       

     

       15
       15
       +
         meta = git.meta // {

     

       16
       16
       +
           description = "A package to use HTTP-based ocaml-git with MirageOS backend";

     

       17
       17
       +
         };

     

       18
       18
       +
       }

+17

pkgs/development/ocaml-modules/git/cohttp-unix.nix

···

       1
       1
       +
       { buildDunePackage, git, git-cohttp

     

       2
       2
       +
       , cohttp-lwt-unix, cohttp-lwt, fmt, lwt, result, rresult, uri

     

       3
       3
       +
       }:

     

       4
       4
       +
       

     

       5
       5
       +
       buildDunePackage {

     

       6
       6
       +
         pname = "git-cohttp-unix";

     

       7
       7
       +
       

     

       8
       8
       +
         inherit (git) version src minimumOCamlVersion useDune2;

     

       9
       9
       +
       

     

       10
       10
       +
         propagatedBuildInputs = [

     

       11
       11
       +
           git git-cohttp cohttp-lwt-unix cohttp-lwt fmt lwt result rresult uri

     

       12
       12
       +
         ];

     

       13
       13
       +
       

     

       14
       14
       +
         meta = git.meta // {

     

       15
       15
       +
           description = "A package to use HTTP-based ocaml-git with Unix backend";

     

       16
       16
       +
         };

     

       17
       17
       +
       }

+19

pkgs/development/ocaml-modules/git/cohttp.nix

···

       1
       1
       +
       { buildDunePackage, git

     

       2
       2
       +
       , cohttp, cohttp-lwt, fmt, lwt, result, rresult, uri

     

       3
       3
       +
       , alcotest, alcotest-lwt, bigstringaf, cstruct, logs

     

       4
       4
       +
       , mirage-flow, ke

     

       5
       5
       +
       }:

     

       6
       6
       +
       

     

       7
       7
       +
       buildDunePackage rec {

     

       8
       8
       +
         pname = "git-cohttp";

     

       9
       9
       +
       

     

       10
       10
       +
         inherit (git) version minimumOCamlVersion src useDune2;

     

       11
       11
       +
       

     

       12
       12
       +
         propagatedBuildInputs = [

     

       13
       13
       +
           git cohttp cohttp-lwt fmt lwt result rresult uri

     

       14
       14
       +
         ];

     

       15
       15
       +
       

     

       16
       16
       +
         meta = git.meta // {

     

       17
       17
       +
           description = "A package to use HTTP-based ocaml-git with Unix backend";

     

       18
       18
       +
         };

     

       19
       19
       +
       }

+11 -7

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

···

       1
       1
        
       { stdenv, lib, fetchurl, buildDunePackage

     

       2
       2
        
       , alcotest, mtime, mirage-crypto-rng, tls, git-binary

     

       3
       3
        
       , angstrom, astring, cstruct, decompress, digestif, encore, duff, fmt, checkseum

     

       4
       4
       -
       , fpath, hex, ke, logs, lru, ocaml_lwt, ocamlgraph, ocplib-endian, uri, rresult

     

       5
       5
       -
       , stdlib-shims

     

       4
       4
       +
       , fpath, ke, logs, lwt, ocamlgraph, uri, rresult

     

       5
       5
       +
       , result, bigstringaf, optint, mirage-flow, domain-name, emile

     

       6
       6
       +
       , mimic, carton, carton-lwt, carton-git, ipaddr, psq, crowbar, alcotest-lwt

     

       6
       7
        
       }:

     

       7
       8
        
       

     

       8
       9
        
       buildDunePackage rec {

     

       9
       10
        
         pname = "git";

     

       10
       10
       -
         version = "2.1.3";

     

       11
       11
       +
         version = "3.2.0";

     

       11
       12
        
       

     

       12
       12
       -
         minimumOCamlVersion = "4.07";

     

       13
       13
       +
         minimumOCamlVersion = "4.08";

     

       13
       14
        
         useDune2 = true;

     

       14
       15
        
       

     

       15
       16
        
         src = fetchurl {

     

       16
       17
        
           url = "https://github.com/mirage/ocaml-git/releases/download/${version}/git-${version}.tbz";

     

       17
       17
       -
           sha256 = "1ppllv65vrkfrmx46aiq5879isffcjmg92z9rv2kh92a83h4lqax";

     

       18
       18
       +
           sha256 = "14rq7h1n5v2n0507ycbac8sq21xnzhgirxmlmqv4j5k3aajdcj16";

     

       18
       19
        
         };

     

       19
       20
        
       

     

       20
       21
        
         propagatedBuildInputs = [

     

       21
       22
        
           angstrom astring checkseum cstruct decompress digestif encore duff fmt fpath

     

       22
       22
       -
           hex ke logs lru ocaml_lwt ocamlgraph ocplib-endian uri rresult stdlib-shims

     

       23
       23
       +
           ke logs lwt ocamlgraph uri rresult result bigstringaf optint mirage-flow

     

       24
       24
       +
           domain-name emile mimic carton carton-lwt carton-git ipaddr psq

     

       25
       25
       +
         ];

     

       26
       26
       +
         checkInputs = [

     

       27
       27
       +
           alcotest alcotest-lwt mtime mirage-crypto-rng tls git-binary crowbar

     

       23
       28
        
         ];

     

       24
       24
       -
         checkInputs = [ alcotest mtime mirage-crypto-rng tls git-binary ];

     

       25
       29
        
         doCheck = !stdenv.isAarch64;

     

       26
       30
        
       

     

       27
       31
        
         meta = {

+44

pkgs/development/ocaml-modules/git/unix.nix

···

       1
       1
       +
       { buildDunePackage, fetchpatch, git

     

       2
       2
       +
       , mmap, rresult, result, bigstringaf

     

       3
       3
       +
       , fmt, bos, fpath, uri, digestif, logs, lwt, git-cohttp-unix

     

       4
       4
       +
       , mirage-clock, mirage-clock-unix, astring, awa, cmdliner

     

       5
       5
       +
       , cohttp-lwt-unix, decompress, domain-name, ipaddr, mtime

     

       6
       6
       +
       , tcpip, awa-mirage, mirage-flow

     

       7
       7
       +
       , alcotest, alcotest-lwt, base64, cstruct

     

       8
       8
       +
       , ke, mirage-crypto-rng, ocurl, git-binary

     

       9
       9
       +
       }:

     

       10
       10
       +
       

     

       11
       11
       +
       buildDunePackage {

     

       12
       12
       +
         pname = "git-unix";

     

       13
       13
       +
         inherit (git) version src minimumOCamlVersion;

     

       14
       14
       +
       

     

       15
       15
       +
         useDune2 = true;

     

       16
       16
       +
       

     

       17
       17
       +
         buildInputs = [

     

       18
       18
       +
           awa awa-mirage cmdliner git-cohttp-unix

     

       19
       19
       +
           mirage-clock mirage-clock-unix tcpip

     

       20
       20
       +
         ];

     

       21
       21
       +
         propagatedBuildInputs = [

     

       22
       22
       +
           mmap rresult result bigstringaf

     

       23
       23
       +
           fmt bos fpath uri digestif logs lwt

     

       24
       24
       +
           astring cohttp-lwt-unix decompress

     

       25
       25
       +
           domain-name ipaddr mtime mirage-flow

     

       26
       26
       +
         ];

     

       27
       27
       +
         checkInputs = [

     

       28
       28
       +
           alcotest alcotest-lwt base64 cstruct ke

     

       29
       29
       +
           mirage-crypto-rng ocurl git-binary

     

       30
       30
       +
         ];

     

       31
       31
       +
         doCheck = true;

     

       32
       32
       +
       

     

       33
       33
       +
         patches = [

     

       34
       34
       +
           (fetchpatch {

     

       35
       35
       +
             url = "https://github.com/mirage/ocaml-git/commit/09b41073fa869c0a595e1d8ed7224d539682af1c.patch";

     

       36
       36
       +
             sha256 = "1avbxv60gbrll9gny1pl6jwbx5b8282h3frhzy2ghb0fx1pggp6w";

     

       37
       37
       +
           })

     

       38
       38
       +
         ];

     

       39
       39
       +
       

     

       40
       40
       +
         meta = {

     

       41
       41
       +
           description = "Unix backend for the Git protocol(s)";

     

       42
       42
       +
           inherit (git.meta) homepage license maintainers;

     

       43
       43
       +
         };

     

       44
       44
       +
       }

+11 -13

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

···

       1
       1
       -
       { lib, fetchFromGitHub, fetchpatch, buildDunePackage, decompress }:

     

       1
       1
       +
       { lib, fetchurl, buildDunePackage

     

       2
       2
       +
       , decompress, stdlib-shims, alcotest

     

       3
       3
       +
       }:

     

       2
       4
        
       

     

       3
       5
        
       buildDunePackage rec {

     

       4
       6
        
         minimumOCamlVersion = "4.07";

     

       5
       5
       -
         version = "20191011";

     

       7
       7
       +
         version = "20200929";

     

       6
       8
        
         pname = "imagelib";

     

       7
       9
        
       

     

       8
       10
        
         useDune2 = true;

     

       9
       11
        
       

     

       10
       10
       -
         src = fetchFromGitHub {

     

       11
       11
       -
           owner = "rlepigre";

     

       12
       12
       -
           repo = "ocaml-imagelib";

     

       13
       13
       -
           rev = "03fed7733825cef7e0465163f398f6af810e2e75";

     

       14
       14
       -
           sha256 = "0h7vgyss42nhlfqpbdnb54nxq86rskqi2ilx8b87r0hi19hqx463";

     

       12
       12
       +
         src = fetchurl {

     

       13
       13
       +
           url = "https://github.com/rlepigre/ocaml-imagelib/releases/download/ocaml-imagelib_${version}/imagelib-ocaml-imagelib_${version}.tbz";

     

       14
       14
       +
           sha256 = "1wyq4xxj0dxwafbcmd7jylsd8w1gbyl7j4ak6jbq1n0ardwmpwca";

     

       15
       15
        
         };

     

       16
       16
        
       

     

       17
       17
       -
         patches = [ (fetchpatch {

     

       18
       18
       -
           url = "https://github.com/rlepigre/ocaml-imagelib/pull/24/commits/4704fd44adcda62e0d96ea5b1927071326aa6111.patch";

     

       19
       19
       -
           sha256 = "0ipjab1hfa2v2pnd8g1k3q2ia0plgiw7crm3fa4w2aqpzdyabkb9";

     

       20
       20
       -
         }) ];

     

       17
       17
       +
         propagatedBuildInputs = [ decompress stdlib-shims ];

     

       21
       18
        
       

     

       22
       22
       -
         propagatedBuildInputs = [ decompress ];

     

       19
       19
       +
         doCheck = true;

     

       20
       20
       +
         checkInputs = [ alcotest ];

     

       23
       21
        
       

     

       24
       22
        
         meta = {

     

       25
       23
        
           description = "Image formats such as PNG and PPM in OCaml";

     

       26
       24
        
           license = lib.licenses.lgpl3;

     

       27
       25
        
           maintainers = [ lib.maintainers.vbgl ];

     

       28
       28
       -
           inherit (src.meta) homepage;

     

       26
       26
       +
           homepage = "https://github.com/rlepigre/ocaml-imagelib";

     

       29
       27
        
         };

     

       30
       28
        
       }

-8

pkgs/development/ocaml-modules/imagelib/unix.nix

···

       1
       1
       -
       { buildDunePackage, imagelib }:

     

       2
       2
       -
       

     

       3
       3
       -
       buildDunePackage {

     

       4
       4
       -
         pname = "imagelib-unix";

     

       5
       5
       -
         inherit (imagelib) version src useDune2 meta;

     

       6
       6
       -
       

     

       7
       7
       -
         propagatedBuildInputs = [ imagelib ];

     

       8
       8
       -
       }

+16 -6

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

···

       1
       1
       -
       { lib, fetchurl, buildDunePackage, fmt, logs, mtime, stdlib-shims }:

     

       1
       1
       +
       { lib, fetchurl, buildDunePackage

     

       2
       2
       +
       , repr, ppx_repr, fmt, logs, mtime, stdlib-shims

     

       3
       3
       +
       , cmdliner, progress, semaphore-compat

     

       4
       4
       +
       , alcotest, crowbar, re

     

       5
       5
       +
       }:

     

       2
       6
        
       

     

       3
       7
        
       buildDunePackage rec {

     

       4
       8
        
         pname = "index";

     

       5
       5
       -
         version = "1.2.1";

     

       9
       9
       +
         version = "1.3.0";

     

       6
       10
        
       

     

       7
       7
       -
         minimumOCamlVersion = "4.07";

     

       11
       11
       +
         minimumOCamlVersion = "4.08";

     

       12
       12
       +
       

     

       13
       13
       +
         useDune2 = true;

     

       8
       14
        
       

     

       9
       15
        
         src = fetchurl {

     

       10
       16
        
           url = "https://github.com/mirage/index/releases/download/${version}/index-${version}.tbz";

     

       11
       11
       -
           sha256 = "1a9b6rsazrjy07syxl9ix5002i95mlvx5vk7nl2x9cs6s0zw906d";

     

       17
       17
       +
           sha256 = "00qwhwg79scs5bgp8nbppv06qs9yhicf686q7lh64ngh0642iz6n";

     

       12
       18
        
         };

     

       13
       19
        
       

     

       14
       20
        
         buildInputs = [ stdlib-shims ];

     

       15
       15
       -
         propagatedBuildInputs = [ fmt logs mtime ];

     

       21
       21
       +
         propagatedBuildInputs = [

     

       22
       22
       +
           fmt logs mtime repr ppx_repr cmdliner progress semaphore-compat

     

       23
       23
       +
         ];

     

       24
       24
       +
       

     

       25
       25
       +
         doCheck = true;

     

       26
       26
       +
         checkInputs = [ alcotest crowbar re ];

     

       16
       27
        
       

     

       17
       28
        
         meta = {

     

       18
       29
        
           homepage = "https://github.com/mirage/index";

     
···

       20
       31
        
           license = lib.licenses.mit;

     

       21
       32
        
           maintainers = [ lib.maintainers.vbgl ];

     

       22
       33
        
         };

     

       23
       23
       -
       

     

       24
       34
        
       }

+2 -2

pkgs/development/ocaml-modules/irmin/chunk.nix

···

       1
       1
       -
       { lib, buildDunePackage, irmin, irmin-mem, irmin-test }:

     

       1
       1
       +
       { lib, buildDunePackage, irmin, irmin-test, alcotest }:

     

       2
       2
        
       

     

       3
       3
        
       buildDunePackage rec {

     

       4
       4
        
       

     
···

       8
       8
        
         propagatedBuildInputs = [ irmin ];

     

       9
       9
        
       

     

       10
       10
        
         doCheck = true;

     

       11
       11
       -
         checkInputs = [ irmin-mem irmin-test ];

     

       11
       11
       +
         checkInputs = [ alcotest irmin-test ];

     

       12
       12
        
       

     

       13
       13
        
         meta = irmin.meta // {

     

       14
       14
        
           description = "Irmin backend which allow to store values into chunks";

+27

pkgs/development/ocaml-modules/irmin/containers.nix

···

       1
       1
       +
       { buildDunePackage

     

       2
       2
       +
       , irmin, irmin-unix, irmin-git, ppx_irmin, lwt, mtime

     

       3
       3
       +
       , alcotest, alcotest-lwt

     

       4
       4
       +
       }:

     

       5
       5
       +
       

     

       6
       6
       +
       buildDunePackage {

     

       7
       7
       +
         pname = "irmin-containers";

     

       8
       8
       +
       

     

       9
       9
       +
         inherit (ppx_irmin) src version useDune2;

     

       10
       10
       +
       

     

       11
       11
       +
         nativeBuildInputs = [

     

       12
       12
       +
           ppx_irmin

     

       13
       13
       +
         ];

     

       14
       14
       +
       

     

       15
       15
       +
         propagatedBuildInputs = [

     

       16
       16
       +
           irmin irmin-unix irmin-git ppx_irmin lwt mtime

     

       17
       17
       +
         ];

     

       18
       18
       +
       

     

       19
       19
       +
         doCheck = true;

     

       20
       20
       +
         checkInputs = [

     

       21
       21
       +
           alcotest alcotest-lwt

     

       22
       22
       +
         ];

     

       23
       23
       +
       

     

       24
       24
       +
         meta = ppx_irmin.meta // {

     

       25
       25
       +
           description = "Mergeable Irmin data structures";

     

       26
       26
       +
         };

     

       27
       27
       +
       }

+18 -5

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

···

       1
       1
       -
       { lib, fetchurl, buildDunePackage

     

       1
       1
       +
       { lib, buildDunePackage

     

       2
       2
        
       , astring, base64, digestif, fmt, jsonm, logs, ocaml_lwt, ocamlgraph, uri

     

       3
       3
       -
       , alcotest, hex, ppx_irmin

     

       3
       3
       +
       , repr, ppx_irmin, bheap

     

       4
       4
        
       }:

     

       5
       5
        
       

     

       6
       6
        
       buildDunePackage {

     
···

       11
       11
        
         useDune2 = true;

     

       12
       12
        
         minimumOCamlVersion = "4.07";

     

       13
       13
        
       

     

       14
       14
       -
         propagatedBuildInputs = [ astring base64 digestif fmt jsonm logs ocaml_lwt ocamlgraph uri ];

     

       14
       14
       +
         propagatedBuildInputs = [

     

       15
       15
       +
           astring

     

       16
       16
       +
           base64

     

       17
       17
       +
           digestif

     

       18
       18
       +
           fmt

     

       19
       19
       +
           jsonm

     

       20
       20
       +
           logs

     

       21
       21
       +
           ocaml_lwt

     

       22
       22
       +
           ocamlgraph

     

       23
       23
       +
           uri

     

       24
       24
       +
           repr

     

       25
       25
       +
           bheap

     

       26
       26
       +
           ppx_irmin

     

       27
       27
       +
         ];

     

       15
       28
        
       

     

       16
       16
       -
         checkInputs = [ alcotest hex ppx_irmin ];

     

       17
       17
       -
         doCheck = true;

     

       29
       29
       +
         # circular dependency on irmin-mem

     

       30
       30
       +
         doCheck = false;

     

       18
       31
        
       

     

       19
       32
        
         meta = ppx_irmin.meta // {

     

       20
       33
        
           description = "A distributed database built on the same principles as Git";

+20 -4

pkgs/development/ocaml-modules/irmin/git.nix

···

       1
       1
       -
       { lib, buildDunePackage, git, irmin, irmin-mem, irmin-test, git-unix }:

     

       1
       1
       +
       { lib, buildDunePackage

     

       2
       2
       +
       , git, irmin, irmin-test, ppx_irmin, git-cohttp-unix, git-unix

     

       3
       3
       +
       , digestif, cstruct, fmt, astring, fpath, logs, lwt, uri

     

       4
       4
       +
       , mtime, alcotest

     

       5
       5
       +
       }:

     

       2
       6
        
       

     

       3
       3
       -
       buildDunePackage rec {

     

       7
       7
       +
       buildDunePackage {

     

       4
       8
        
       

     

       5
       9
        
         pname = "irmin-git";

     

       6
       10
        
       

     
···

       8
       12
        
       

     

       9
       13
        
         useDune2 = true;

     

       10
       14
        
       

     

       11
       11
       -
         propagatedBuildInputs = [ git irmin ];

     

       15
       15
       +
         propagatedBuildInputs = [

     

       16
       16
       +
           git

     

       17
       17
       +
           irmin

     

       18
       18
       +
           ppx_irmin

     

       19
       19
       +
           digestif

     

       20
       20
       +
           cstruct

     

       21
       21
       +
           fmt

     

       22
       22
       +
           astring

     

       23
       23
       +
           fpath

     

       24
       24
       +
           logs

     

       25
       25
       +
           lwt

     

       26
       26
       +
           uri

     

       27
       27
       +
         ];

     

       12
       28
        
       

     

       13
       13
       -
         checkInputs = lib.optionals doCheck [ git-unix irmin-mem irmin-test ];

     

       29
       29
       +
         checkInputs = [ mtime alcotest git-cohttp-unix git-unix irmin-test ];

     

       14
       30
        
       

     

       15
       31
        
         doCheck = true;

     

       16
       32

+2 -2

pkgs/development/ocaml-modules/irmin/http.nix

···

       1
       1
        
       { lib, buildDunePackage, cohttp-lwt, irmin, webmachine

     

       2
       2
       -
       , checkseum, git-unix, irmin-git, irmin-mem, irmin-test

     

       2
       2
       +
       , checkseum, git-unix, irmin-git, irmin-test, digestif, git-cohttp-unix

     

       3
       3
        
       }:

     

       4
       4
        
       

     

       5
       5
        
       buildDunePackage rec {

     
···

       12
       12
        
       

     

       13
       13
        
         propagatedBuildInputs = [ cohttp-lwt irmin webmachine ];

     

       14
       14
        
       

     

       15
       15
       -
         checkInputs = lib.optionals doCheck [ checkseum git-unix irmin-git irmin-mem irmin-test ];

     

       15
       15
       +
         checkInputs = [ digestif checkseum git-cohttp-unix git-unix irmin-git irmin-test ];

     

       16
       16
        
       

     

       17
       17
        
         doCheck = true;

     

       18
       18

+21

pkgs/development/ocaml-modules/irmin/layers.nix

···

       1
       1
       +
       { buildDunePackage, irmin, mtime, logs, lwt }:

     

       2
       2
       +
       

     

       3
       3
       +
       buildDunePackage {

     

       4
       4
       +
         pname = "irmin-layers";

     

       5
       5
       +
       

     

       6
       6
       +
         inherit (irmin) version src useDune2;

     

       7
       7
       +
       

     

       8
       8
       +
         propagatedBuildInputs = [

     

       9
       9
       +
           irmin

     

       10
       10
       +
           mtime

     

       11
       11
       +
           logs

     

       12
       12
       +
           lwt

     

       13
       13
       +
         ];

     

       14
       14
       +
       

     

       15
       15
       +
         # mutual dependency on irmin-test

     

       16
       16
       +
         doCheck = false;

     

       17
       17
       +
       

     

       18
       18
       +
         meta = irmin.meta // {

     

       19
       19
       +
           description = "Combine different Irmin stores into a single, layered store";

     

       20
       20
       +
         };

     

       21
       21
       +
       }

-21

pkgs/development/ocaml-modules/irmin/mem.nix

···

       1
       1
       -
       { lib, buildDunePackage, irmin, irmin-test }:

     

       2
       2
       -
       

     

       3
       3
       -
       buildDunePackage rec {

     

       4
       4
       -
       

     

       5
       5
       -
         pname = "irmin-mem";

     

       6
       6
       -
       

     

       7
       7
       -
         inherit (irmin) version src;

     

       8
       8
       -
       

     

       9
       9
       -
         useDune2 = true;

     

       10
       10
       -
       

     

       11
       11
       -
         propagatedBuildInputs = [ irmin ];

     

       12
       12
       -
       

     

       13
       13
       -
         checkInputs = lib.optional doCheck irmin-test;

     

       14
       14
       -
       

     

       15
       15
       -
         doCheck = true;

     

       16
       16
       -
       

     

       17
       17
       -
         meta = irmin.meta // {

     

       18
       18
       -
           description = "Generic in-memory Irmin stores";

     

       19
       19
       -
         };

     

       20
       20
       -
       

     

       21
       21
       -
       }

+27

pkgs/development/ocaml-modules/irmin/mirage-git.nix

···

       1
       1
       +
       { buildDunePackage, irmin-mirage, irmin-git

     

       2
       2
       +
       , mirage-kv, cohttp, conduit-lwt, conduit-mirage

     

       3
       3
       +
       , git-cohttp-mirage, fmt, git, lwt, mirage-clock, uri

     

       4
       4
       +
       }:

     

       5
       5
       +
       

     

       6
       6
       +
       buildDunePackage {

     

       7
       7
       +
         pname = "irmin-mirage-git";

     

       8
       8
       +
       

     

       9
       9
       +
         inherit (irmin-mirage) version src useDune2;

     

       10
       10
       +
       

     

       11
       11
       +
         propagatedBuildInputs = [

     

       12
       12
       +
           irmin-mirage

     

       13
       13
       +
           irmin-git

     

       14
       14
       +
           mirage-kv

     

       15
       15
       +
           cohttp

     

       16
       16
       +
           conduit-lwt

     

       17
       17
       +
           conduit-mirage

     

       18
       18
       +
           git-cohttp-mirage

     

       19
       19
       +
           fmt

     

       20
       20
       +
           git

     

       21
       21
       +
           lwt

     

       22
       22
       +
           mirage-clock

     

       23
       23
       +
           uri

     

       24
       24
       +
         ];

     

       25
       25
       +
       

     

       26
       26
       +
         inherit (irmin-mirage) meta;

     

       27
       27
       +
       }

+21

pkgs/development/ocaml-modules/irmin/mirage-graphql.nix

···

       1
       1
       +
       { buildDunePackage, irmin-mirage, irmin-graphql

     

       2
       2
       +
       , mirage-clock, cohttp-lwt, lwt, uri, git

     

       3
       3
       +
       }:

     

       4
       4
       +
       

     

       5
       5
       +
       buildDunePackage {

     

       6
       6
       +
         pname = "irmin-mirage-graphql";

     

       7
       7
       +
       

     

       8
       8
       +
         inherit (irmin-mirage) version src useDune2;

     

       9
       9
       +
       

     

       10
       10
       +
         propagatedBuildInputs = [

     

       11
       11
       +
           irmin-mirage

     

       12
       12
       +
           irmin-graphql

     

       13
       13
       +
           mirage-clock

     

       14
       14
       +
           cohttp-lwt

     

       15
       15
       +
           lwt

     

       16
       16
       +
           uri

     

       17
       17
       +
           git

     

       18
       18
       +
         ];

     

       19
       19
       +
       

     

       20
       20
       +
         inherit (irmin-mirage) meta;

     

       21
       21
       +
       }

+15

pkgs/development/ocaml-modules/irmin/mirage.nix

···

       1
       1
       +
       { buildDunePackage, irmin, fmt, ptime, mirage-clock }:

     

       2
       2
       +
       

     

       3
       3
       +
       buildDunePackage {

     

       4
       4
       +
         pname = "irmin-mirage";

     

       5
       5
       +
       

     

       6
       6
       +
         inherit (irmin) version src useDune2;

     

       7
       7
       +
       

     

       8
       8
       +
         propagatedBuildInputs = [

     

       9
       9
       +
           irmin fmt ptime mirage-clock

     

       10
       10
       +
         ];

     

       11
       11
       +
       

     

       12
       12
       +
         meta = irmin.meta // {

     

       13
       13
       +
           description = "MirageOS-compatible Irmin stores";

     

       14
       14
       +
         };

     

       15
       15
       +
       }

+6 -3

pkgs/development/ocaml-modules/irmin/pack.nix

···

       1
       1
       -
       { lib, buildDunePackage, alcotest-lwt, index, irmin, irmin-test, ocaml_lwt }:

     

       1
       1
       +
       { lib, buildDunePackage

     

       2
       2
       +
       , alcotest-lwt, index, irmin, irmin-layers, irmin-test, ocaml_lwt, fpath

     

       3
       3
       +
       }:

     

       2
       4
        
       

     

       3
       5
        
       buildDunePackage rec {

     

       4
       6
        
         minimumOCamlVersion = "4.02.3";

     
···

       9
       11
        
       

     

       10
       12
        
         useDune2 = true;

     

       11
       13
        
       

     

       12
       12
       -
         propagatedBuildInputs = [ index irmin ocaml_lwt ];

     

       14
       14
       +
         buildInputs = [ fpath ];

     

       15
       15
       +
         propagatedBuildInputs = [ index irmin irmin-layers ocaml_lwt ];

     

       13
       16
        
       

     

       14
       14
       -
         checkInputs = lib.optionals doCheck [ alcotest-lwt irmin-test ];

     

       17
       17
       +
         checkInputs = [ alcotest-lwt irmin-test ];

     

       15
       18
        
       

     

       16
       19
        
         doCheck = true;

     

       17
       20

+8 -7

pkgs/development/ocaml-modules/irmin/ppx.nix

···

       1
       1
       -
       { lib, fetchurl, buildDunePackage, ppxlib, ocaml-syntax-shims }:

     

       1
       1
       +
       { lib, fetchurl, buildDunePackage, ppxlib, ppx_repr }:

     

       2
       2
        
       

     

       3
       3
        
       buildDunePackage rec {

     

       4
       4
        
         pname = "ppx_irmin";

     

       5
       5
       -
         version = "2.2.0";

     

       5
       5
       +
         version = "2.4.0";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchurl {

     

       8
       8
        
           url = "https://github.com/mirage/irmin/releases/download/${version}/irmin-${version}.tbz";

     

       9
       9
       -
           sha256 = "0gzw918b661qkvd140hilww9jsc49rxsxz1k4iihyvikjn202km4";

     

       9
       9
       +
           sha256 = "1b6lav5br1b83cwdc3gj9mqkzhlbfjrbyjx0107zvj54m82dbrxb";

     

       10
       10
        
         };

     

       11
       11
        
       

     

       12
       12
       -
         minimumOCamlVersion = "4.06";

     

       12
       12
       +
         minimumOCamlVersion = "4.08";

     

       13
       13
        
       

     

       14
       14
        
         useDune2 = true;

     

       15
       15
        
       

     

       16
       16
       -
         buildInputs = [ ocaml-syntax-shims ];

     

       17
       17
       -
         propagatedBuildInputs = [ ppxlib ];

     

       16
       16
       +
         propagatedBuildInputs = [

     

       17
       17
       +
           ppx_repr

     

       18
       18
       +
           ppxlib

     

       19
       19
       +
         ];

     

       18
       20
        
       

     

       19
       21
        
         # tests depend on irmin, would create mutual dependency

     

       20
       20
       -
         # opt to test irmin instead of ppx_irmin

     

       21
       22
        
         doCheck = false;

     

       22
       23
        
       

     

       23
       24
        
         meta = {

+6 -2

pkgs/development/ocaml-modules/irmin/test.nix

···

       1
       1
       -
       { buildDunePackage, alcotest, cmdliner, irmin, metrics-unix, mtime }:

     

       1
       1
       +
       { buildDunePackage

     

       2
       2
       +
       , alcotest, cmdliner, irmin, metrics-unix, mtime, irmin-layers

     

       3
       3
       +
       }:

     

       2
       4
        
       

     

       3
       5
        
       buildDunePackage {

     

       4
       6
        
       

     
···

       8
       10
        
       

     

       9
       11
        
         useDune2 = true;

     

       10
       12
        
       

     

       11
       11
       -
         propagatedBuildInputs = [ alcotest cmdliner irmin metrics-unix mtime ];

     

       13
       13
       +
         propagatedBuildInputs = [

     

       14
       14
       +
           alcotest cmdliner irmin metrics-unix mtime irmin-layers

     

       15
       15
       +
         ];

     

       12
       16
        
       

     

       13
       17
        
         meta = irmin.meta // {

     

       14
       18
        
           description = "Irmin test suite";

+7 -5

pkgs/development/ocaml-modules/irmin/unix.nix

···

       1
       1
        
       { lib, buildDunePackage

     

       2
       2
       -
       , checkseum, cmdliner, git-unix, yaml

     

       3
       3
       -
       , irmin, irmin-fs, irmin-git, irmin-graphql, irmin-http, irmin-mem, irmin-pack, irmin-watcher

     

       4
       4
       -
       , irmin-test

     

       2
       2
       +
       , checkseum, cmdliner, git-unix, git-cohttp-unix, yaml, fpath

     

       3
       3
       +
       , irmin, irmin-fs, irmin-git, irmin-graphql, irmin-http

     

       4
       4
       +
       , irmin-pack, irmin-watcher, irmin-test

     

       5
       5
        
       }:

     

       6
       6
        
       

     

       7
       7
        
       buildDunePackage rec {

     
···

       12
       12
        
       

     

       13
       13
        
         useDune2 = true;

     

       14
       14
        
       

     

       15
       15
       -
         propagatedBuildInputs = [ checkseum cmdliner git-unix yaml

     

       16
       16
       -
           irmin irmin-fs irmin-git irmin-graphql irmin-http irmin-mem irmin-pack irmin-watcher

     

       15
       15
       +
         propagatedBuildInputs = [

     

       16
       16
       +
           checkseum cmdliner git-unix yaml fpath

     

       17
       17
       +
           irmin irmin-fs irmin-git irmin-graphql irmin-http

     

       18
       18
       +
           irmin-pack irmin-watcher git-cohttp-unix

     

       17
       19
        
         ];

     

       18
       20
        
       

     

       19
       21
        
         checkInputs = lib.optional doCheck irmin-test;

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

···

       6
       6
        
       

     

       7
       7
        
         minimumOCamlVersion = "4.03";

     

       8
       8
        
       

     

       9
       9
       +
         useDune2 = true;

     

       10
       10
       +
       

     

       9
       11
        
         src = fetchurl {

     

       10
       12
        
           url = "https://github.com/gildor478/ocaml-gettext/releases/download/v${version}/gettext-v${version}.tbz";

     

       11
       13
        
           sha256 = "19ynsldb21r539fiwz1f43apsdnx7hj2a2d9qr9wg2hva9y2qrwb";

+5 -3

pkgs/development/ocaml-modules/ocaml-gettext/stub.nix

···

       1
       1
       -
       { lib, buildDunePackage, ocaml_gettext, ounit }:

     

       1
       1
       +
       { buildDunePackage, ocaml_gettext, dune-configurator, ounit }:

     

       2
       2
        
       

     

       3
       3
        
       buildDunePackage rec {

     

       4
       4
        
       

     

       5
       5
        
         pname = "gettext-stub";

     

       6
       6
        
       

     

       7
       7
       -
         inherit (ocaml_gettext) src version meta;

     

       7
       7
       +
         inherit (ocaml_gettext) src version useDune2 meta;

     

       8
       8
       +
       

     

       9
       9
       +
         buildInputs = [ dune-configurator ];

     

       8
       10
        
       

     

       9
       11
        
         propagatedBuildInputs = [ ocaml_gettext ];

     

       10
       12
        
       

     

       11
       13
        
         doCheck = true;

     

       12
       14
        
       

     

       13
       13
       -
         checkInputs = lib.optional doCheck ounit;

     

       15
       15
       +
         checkInputs = [ ounit ];

     

       14
       16
        
       }

+8 -2

pkgs/development/ocaml-modules/wodan/irmin.nix

···

       15
       15
        
           wodan

     

       16
       16
        
         ];

     

       17
       17
        
       

     

       18
       18
       -
         meta = wodan.meta // { description = "Wodan as an Irmin store"; };

     

       19
       19
       -
       

     

       18
       18
       +
         meta = wodan.meta // {

     

       19
       19
       +
           # wodan is currently incompatible with irmin 2.3.0.

     

       20
       20
       +
           # additionally upgrading to current master (unclear

     

       21
       21
       +
           # if the issue is fixed there) is not possible as it

     

       22
       22
       +
           # depends on a custom fork of mirage-block

     

       23
       23
       +
           broken = true;

     

       24
       24
       +
           description = "Wodan as an Irmin store";

     

       25
       25
       +
         };

     

       20
       26
        
       }

+2 -2

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

···

       2
       2
        
       

     

       3
       3
        
       buildPythonPackage rec {

     

       4
       4
        
         pname = "aioesphomeapi";

     

       5
       5
       -
         version = "2.6.4";

     

       5
       5
       +
         version = "2.6.5";

     

       6
       6
        
       

     

       7
       7
        
         disabled = !isPy3k;

     

       8
       8
        
       

     

       9
       9
        
         src = fetchPypi {

     

       10
       10
        
           inherit pname version;

     

       11
       11
       -
           sha256 = "d8def7a909c0471479e1d8b0965de6bb7644b8de315d6e578f9d848b8a6812d0";

     

       11
       11
       +
           sha256 = "sha256-inktluPKefrFQCF2yadvHwT9Rw+pJLw8pjdUc35IJoc=";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         propagatedBuildInputs = [ attrs protobuf zeroconf ];

+2 -2

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

···

       7
       7
        
       

     

       8
       8
        
       buildPythonPackage rec {

     

       9
       9
        
         pname = "hatasmota";

     

       10
       10
       -
         version = "0.2.8";

     

       10
       10
       +
         version = "0.2.9";

     

       11
       11
        
       

     

       12
       12
        
         src = fetchFromGitHub {

     

       13
       13
        
           owner = "emontnemery";

     

       14
       14
        
           repo = pname;

     

       15
       15
        
           rev = version;

     

       16
       16
       -
           sha256 = "sha256-DuVpo+g5VS7bkj/DZi0vNOAPjPkzfIA5I2BD5KJ/rNQ=";

     

       16
       16
       +
           sha256 = "sha256-+4jlzemF5f4Qz4QHDaErsmVHq1Pjn/vsvoq/oCbW/hI=";

     

       17
       17
        
         };

     

       18
       18
        
       

     

       19
       19
        
         propagatedBuildInputs = [

+64 -32

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

···

       1
       1
        
       { lib

     

       2
       2
        
       , buildPythonPackage

     

       3
       3
       +
       , pythonOlder

     

       3
       4
        
       , fetchPypi

     

       4
       5
        
       , fetchzip

     

       5
       6
        
       , alembic

     

       6
       6
       -
       , ipython

     

       7
       7
       -
       , jinja2

     

       8
       8
       -
       , python-oauth2

     

       9
       9
       -
       , prometheus_client

     

       10
       7
        
       , async_generator

     

       8
       8
       +
       , certipy

     

       9
       9
       +
       , dateutil

     

       10
       10
       +
       , entrypoints

     

       11
       11
       +
       , jinja2

     

       12
       12
       +
       , jupyter-telemetry

     

       13
       13
       +
       , oauthlib

     

       11
       14
        
       , pamela

     

       15
       15
       +
       , prometheus_client

     

       16
       16
       +
       , requests

     

       12
       17
        
       , sqlalchemy

     

       13
       18
        
       , tornado

     

       14
       19
        
       , traitlets

     

       15
       15
       -
       , requests

     

       16
       16
       -
       , notebook

     

       17
       17
       -
       , pythonOlder

     

       18
       20
        
       , nodePackages

     

       19
       19
       -
       , oauthlib

     

       20
       20
       -
       , certipy

     

       21
       21
       -
       , jupyter-telemetry

     

       21
       21
       +
       , beautifulsoup4

     

       22
       22
       +
       , cryptography

     

       23
       23
       +
       , notebook

     

       24
       24
       +
       , pytest-asyncio

     

       25
       25
       +
       , pytestCheckHook

     

       26
       26
       +
       , requests-mock

     

       27
       27
       +
       , virtualenv

     

       22
       28
        
       }:

     

       23
       29
        
       

     

       24
       30
        
       let

     

       25
       31
        
         # js/css assets that setup.py tries to fetch via `npm install` when building

     

       26
       26
       -
         # from source.

     

       32
       32
       +
         # from source. https://github.com/jupyterhub/jupyterhub/blob/master/package.json

     

       27
       33
        
         bootstrap =

     

       28
       34
        
           fetchzip {

     

       29
       29
       -
             url = "https://registry.npmjs.org/bootstrap/-/bootstrap-3.3.7.tgz";

     

       30
       30
       -
             sha256 = "0r7s54bbf68ri1na9bbabyf12mcpb6zk5ja2q6z82aw1fa4xi3yd";

     

       35
       35
       +
             url = "https://registry.npmjs.org/bootstrap/-/bootstrap-3.4.1.tgz";

     

       36
       36
       +
             sha256 = "1ywmxqdccg0mgx0xknrn1hlrfnhcwphc12y9l91zizx26fqfmzgc";

     

       31
       37
        
           };

     

       32
       38
        
         font-awesome =

     

       33
       39
        
           fetchzip {

     
···

       36
       42
        
           };

     

       37
       43
        
         jquery =

     

       38
       44
        
           fetchzip {

     

       39
       39
       -
             url = "https://registry.npmjs.org/jquery/-/jquery-3.2.1.tgz";

     

       40
       40
       -
             sha256 = "1j6y18miwzafdj8kfpwbmbn9qvgnbnpc7l4arqrhqj33m04xrlgi";

     

       45
       45
       +
             url = "https://registry.npmjs.org/jquery/-/jquery-3.5.1.tgz";

     

       46
       46
       +
             sha256 = "0yi9ql493din1qa1s923nd5zvd0klk1sx00xj1wx2yambmq86vm9";

     

       41
       47
        
           };

     

       42
       48
        
         moment =

     

       43
       49
        
           fetchzip {

     

       44
       44
       -
             url = "https://registry.npmjs.org/moment/-/moment-2.22.2.tgz";

     

       45
       45
       -
             sha256 = "12gb3p0rz5wyjwykv9g0pix7dd352lx1z7rzdjsf2brhwc4ffyip";

     

       50
       50
       +
             url = "https://registry.npmjs.org/moment/-/moment-2.24.0.tgz";

     

       51
       51
       +
             sha256 = "0ifzzla4zffw23g3xvhwx3fj3jny6cjzxfzl1x0317q8wa0c7w5i";

     

       46
       52
        
           };

     

       47
       53
        
         requirejs =

     

       48
       54
        
           fetchzip {

     

       49
       49
       -
             url = "https://registry.npmjs.org/requirejs/-/requirejs-2.3.4.tgz";

     

       50
       50
       -
             sha256 = "0q6mkj0iv341kks06dya6lfs2kdw0n6vc7n4a7aa3ia530fk9vja";

     

       55
       55
       +
             url = "https://registry.npmjs.org/requirejs/-/requirejs-2.3.6.tgz";

     

       56
       56
       +
             sha256 = "165hkli3qcd59cjqvli9r5f92i0h7czkmhcg1cgwamw2d0b7xibz";

     

       51
       57
        
           };

     

       52
       58
        
       

     

       53
       59
        
       in

     

       54
       60
        
       

     

       55
       61
        
       buildPythonPackage rec {

     

       56
       62
        
         pname = "jupyterhub";

     

       57
       57
       -
         version = "1.1.0";

     

       58
       58
       -
         disabled = pythonOlder "3.5";

     

       63
       63
       +
         version = "1.3.0";

     

       64
       64
       +
         disabled = pythonOlder "3.6";

     

       59
       65
        
       

     

       60
       66
        
         src = fetchPypi {

     

       61
       67
        
           inherit pname version;

     

       62
       62
       -
           sha256 = "1mqknz0rxqzx4nc57vscvfh2d4znzlzpy83ancqxdaq3b8i70al5";

     

       68
       68
       +
           sha256 = "13pf6qhimpaxj20871ff5rvwwan59320cdhhrn9cfh6314971zq5";

     

       63
       69
        
         };

     

       64
       70
        
       

     

       65
       71
        
         # Most of this only applies when building from source (e.g. js/css assets are

     
···

       86
       92
        
             "'${nodePackages.configurable-http-proxy}/bin/configurable-http-proxy'"

     

       87
       93
        
       

     

       88
       94
        
           substituteInPlace setup.py --replace \

     

       89
       89
       -
             "'npm', 'run', 'lessc', '--'" \

     

       90
       90
       -
             "'${nodePackages.less}/bin/lessc'"

     

       91
       91
       -
       

     

       92
       92
       -
           substituteInPlace setup.py --replace \

     

       93
       93
       -
             "'npm', 'install', '--progress=false'" \

     

       94
       94
       -
             "'true'"

     

       95
       95
       +
             "'npm'" "'true'"

     

       95
       96
        
       

     

       96
       97
        
           declare -A deps

     

       97
       98
        
           deps[bootstrap]=${bootstrap}

     
···

       109
       110
        
         '';

     

       110
       111
        
       

     

       111
       112
        
         propagatedBuildInputs = [

     

       112
       112
       -
           alembic ipython jinja2 pamela python-oauth2 requests sqlalchemy tornado

     

       113
       113
       -
           traitlets prometheus_client async_generator notebook certipy oauthlib

     

       113
       113
       +
           # https://github.com/jupyterhub/jupyterhub/blob/master/requirements.txt

     

       114
       114
       +
           alembic

     

       115
       115
       +
           async_generator

     

       116
       116
       +
           certipy

     

       117
       117
       +
           dateutil

     

       118
       118
       +
           entrypoints

     

       119
       119
       +
           jinja2

     

       114
       120
        
           jupyter-telemetry

     

       121
       121
       +
           oauthlib

     

       122
       122
       +
           pamela

     

       123
       123
       +
           prometheus_client

     

       124
       124
       +
           requests

     

       125
       125
       +
           sqlalchemy

     

       126
       126
       +
           tornado

     

       127
       127
       +
           traitlets

     

       115
       128
        
         ];

     

       116
       129
        
       

     

       117
       117
       -
         # Disable tests because they take an excessive amount of time to complete.

     

       118
       118
       -
         doCheck = false;

     

       130
       130
       +
         preCheck = ''

     

       131
       131
       +
           substituteInPlace jupyterhub/tests/test_spawner.py --replace \

     

       132
       132
       +
             "'jupyterhub-singleuser'" "'$out/bin/jupyterhub-singleuser'"

     

       133
       133
       +
         '';

     

       119
       134
        
       

     

       135
       135
       +
         checkInputs = [

     

       136
       136
       +
           # https://github.com/jupyterhub/jupyterhub/blob/master/dev-requirements.txt

     

       137
       137
       +
           beautifulsoup4

     

       138
       138
       +
           cryptography

     

       139
       139
       +
           notebook

     

       140
       140
       +
           pytest-asyncio

     

       141
       141
       +
           pytestCheckHook

     

       142
       142
       +
           requests-mock

     

       143
       143
       +
           virtualenv

     

       144
       144
       +
         ];

     

       145
       145
       +
       

     

       146
       146
       +
         disabledTests = [

     

       147
       147
       +
           # Tries to install older versions through pip

     

       148
       148
       +
           "test_upgrade"

     

       149
       149
       +
           # Testcase fails to find requests import

     

       150
       150
       +
           "test_external_service"

     

       151
       151
       +
         ];

     

       120
       152
        
       

     

       121
       153
        
         meta = with lib; {

     

       122
       154
        
           description = "Serves multiple Jupyter notebook instances";

+22 -21

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

···

       1
       1
        
       { lib

     

       2
       2
        
       , buildPythonPackage

     

       3
       3
       +
       , pythonOlder

     

       4
       4
       +
       , fetchPypi

     

       5
       5
       +
       , google_api_python_client

     

       6
       6
       +
       , google-auth-oauthlib

     

       3
       7
        
       , jupyterhub

     

       4
       4
       -
       , globus-sdk

     

       5
       8
        
       , mwoauth

     

       6
       6
       -
       , codecov

     

       7
       7
       -
       , flake8

     

       8
       9
        
       , pyjwt

     

       9
       9
       -
       , pytest

     

       10
       10
       -
       , pytestcov

     

       11
       11
       -
       , pytest-tornado

     

       10
       10
       +
       , pytest-asyncio

     

       11
       11
       +
       , pytestCheckHook

     

       12
       12
        
       , requests-mock

     

       13
       13
       -
       , pythonOlder

     

       14
       14
       -
       , fetchPypi

     

       15
       13
        
       }:

     

       16
       14
        
       

     

       17
       15
        
       buildPythonPackage rec {

     

       18
       16
        
         pname = "oauthenticator";

     

       19
       19
       -
         version = "0.12.3";

     

       17
       17
       +
         version = "0.13.0";

     

       18
       18
       +
         disabled = pythonOlder "3.6";

     

       20
       19
        
       

     

       21
       20
        
         src = fetchPypi {

     

       22
       21
        
           inherit pname version;

     

       23
       23
       -
           sha256 = "f86e18e954ae37796ee149fe01ab0be0707d9e0415d62336ba3447e7b4383461";

     

       22
       22
       +
           sha256 = "5202adcd96ddbbccbc267da02f2d14e977300c81291aaa77be4fd9f2e27cfa37";

     

       24
       23
        
         };

     

       25
       24
        
       

     

       26
       26
       -
         checkPhase = ''

     

       27
       27
       -
           py.test oauthenticator/tests

     

       28
       28
       -
         '';

     

       25
       25
       +
         propagatedBuildInputs = [

     

       26
       26
       +
           jupyterhub

     

       27
       27
       +
         ];

     

       29
       28
        
       

     

       30
       30
       -
         # No tests in archive

     

       31
       31
       -
         doCheck = false;

     

       29
       29
       +
         pytestFlagsArray = [ "oauthenticator/tests" ];

     

       32
       30
        
       

     

       33
       33
       -
         checkInputs = [  globus-sdk mwoauth codecov flake8 pytest

     

       34
       34
       -
           pytestcov pytest-tornado requests-mock pyjwt ];

     

       35
       35
       -
       

     

       36
       36
       -
         propagatedBuildInputs = [ jupyterhub ];

     

       37
       37
       -
       

     

       38
       38
       -
         disabled = pythonOlder "3.4";

     

       31
       31
       +
         checkInputs = [

     

       32
       32
       +
           google_api_python_client

     

       33
       33
       +
           google-auth-oauthlib

     

       34
       34
       +
           mwoauth

     

       35
       35
       +
           pyjwt

     

       36
       36
       +
           pytest-asyncio

     

       37
       37
       +
           pytestCheckHook

     

       38
       38
       +
           requests-mock

     

       39
       39
       +
         ];

     

       39
       40
        
       

     

       40
       41
        
         meta = with lib; {

     

       41
       42
        
           description = "Authenticate JupyterHub users with common OAuth providers, including GitHub, Bitbucket, and more.";

+6 -13

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

···

       1
       1
        
       { lib

     

       2
       2
        
       , buildPythonPackage

     

       3
       3
        
       , fetchPypi

     

       4
       4
       -
       , pytest

     

       4
       4
       +
       , pytestCheckHook

     

       5
       5
        
       , numpy

     

       6
       6
        
       , pandas

     

       7
       7
       -
       , python

     

       8
       7
        
       , setuptools

     

       9
       8
        
       , isPy3k

     

       10
       9
        
       }:

     

       11
       10
        
       

     

       12
       11
        
       buildPythonPackage rec {

     

       13
       12
        
         pname = "xarray";

     

       14
       14
       -
         version = "0.16.1";

     

       13
       13
       +
         version = "0.16.2";

     

       14
       14
       +
         disabled = !isPy3k;

     

       15
       15
        
       

     

       16
       16
        
         src = fetchPypi {

     

       17
       17
        
           inherit pname version;

     

       18
       18
       -
           sha256 = "5e1af056ff834bf62ca57da917159328fab21b1f8c25284f92083016bb2d92a5";

     

       18
       18
       +
           sha256 = "sha256-OOhDnWyRvNW3wPyjSdr44GQ6xohQyYcmLVNSbp19AeQ=";

     

       19
       19
        
         };

     

       20
       20
        
       

     

       21
       21
       -
         checkInputs = [ pytest ];

     

       22
       21
        
         propagatedBuildInputs = [ numpy pandas setuptools ];

     

       22
       22
       +
         checkInputs = [ pytestCheckHook ];

     

       23
       23
        
       

     

       24
       24
       -
         checkPhase = ''

     

       25
       25
       -
           pytest $out/${python.sitePackages}

     

       26
       26
       -
         '';

     

       27
       27
       -
       

     

       28
       28
       -
         # There always seem to be broken tests...

     

       29
       29
       -
         doCheck = false;

     

       30
       30
       -
       

     

       31
       31
       -
         disabled = !isPy3k;

     

       24
       24
       +
         pythonImportsCheck = [ "xarray" ];

     

       32
       25
        
       

     

       33
       26
        
         meta = {

     

       34
       27
        
           description = "N-D labeled arrays and datasets in Python";

+1 -1

pkgs/development/r-modules/cran-packages.nix

···

       5534
       5534
        
         arrApply = derive2 { name="arrApply"; version="2.1"; sha256="0qy7iwi580rrf3sycsbv6qgxsqcdy9pdbnkdrx81j68qni9iw737"; depends=[Rcpp RcppArmadillo]; };

     

       5535
       5535
        
         arrangements = derive2 { name="arrangements"; version="1.1.9"; sha256="0nrlyxgn6667l2rb1q5rvps1anld9aq88qqr3ch2i6zchnqxrdg9"; depends=[gmp R6]; };

     

       5536
       5536
        
         arrayhelpers = derive2 { name="arrayhelpers"; version="1.1-0"; sha256="02rl530qxi1idiqpmzg5wr9vl5c7phizhpj64k5pn8xq9zfxbpaz"; depends=[svUnit]; };

     

       5537
       5537
       -
         arrow = derive2 { name="arrow"; version="2.0.0"; sha256="0n9g8j7bis7aga2icc8gd6mv7fnh2d5m7fy62fqs4z69l69y19r8"; depends=[assertthat bit64 cpp11 purrr R6 rlang tidyselect vctrs]; };

     

       5537
       5537
       +
         arrow = derive { snapshot = "2021-02-01"; } { name="arrow"; version="3.0.0"; sha256="0wgdj6fr4vbz91s76gfwyv2q66p8z3fwf9zgk4112rjhj60q7qfq"; depends=[assertthat bit64 cpp11 purrr R6 rlang tidyselect vctrs]; };

     

       5538
       5538
        
         ars = derive2 { name="ars"; version="0.6"; sha256="0zs1rk3i7pc9wcvxrvjcls194mfbvmkz7cb6pwd1cm3fzjwsyxsp"; depends=[]; };

     

       5539
       5539
        
         arse = derive2 { name="arse"; version="1.0.0"; sha256="0ssaalc058m09gfcr1n0s729rx2plia3zkhlynj67drclyvhyb0i"; depends=[dplyr pracma]; };

     

       5540
       5540
        
         arsenal = derive2 { name="arsenal"; version="3.5.0"; sha256="0avi434wkk3w7axd89a4jwsbb11fi0239mkkla6zasnjwbqgjim0"; depends=[knitr]; };

pkgs/development/r-modules/default.nix

···

       231
       231
        
         };

     

       232
       232
        
       

     

       233
       233
        
         packagesWithNativeBuildInputs = {

     

       234
       234
       +
           arrow = [ pkgs.pkgconfig pkgs.arrow-cpp ];

     

       234
       235
        
           adimpro = [ pkgs.imagemagick ];

     

       235
       236
        
           animation = [ pkgs.which ];

     

       236
       237
        
           audio = [ pkgs.portaudio ];

+1 -1

pkgs/development/tools/rubocop/Gemfile.lock

···

       8
       8
        
           rainbow (3.0.0)

     

       9
       9
        
           regexp_parser (2.0.3)

     

       10
       10
        
           rexml (3.2.4)

     

       11
       11
       -
           rubocop (1.9.1)

     

       11
       11
       +
           rubocop (1.10.0)

     

       12
       12
        
             parallel (~> 1.10)

     

       13
       13
        
             parser (>= 3.0.0.0)

     

       14
       14
        
             rainbow (>= 2.2.2, < 4.0)

+2 -2

pkgs/development/tools/rubocop/gemset.nix

···

       66
       66
        
           platforms = [];

     

       67
       67
        
           source = {

     

       68
       68
        
             remotes = ["https://rubygems.org"];

     

       69
       69
       -
             sha256 = "06npybjypxsrz09z8ivxqfcwzpbgif6z3hwpp0ls8znqlgp3m922";

     

       69
       69
       +
             sha256 = "1ncd6w4sc112j86j9j12ws7flxfi8dk8nal2kyxg7phdfr703qlz";

     

       70
       70
        
             type = "gem";

     

       71
       71
        
           };

     

       72
       72
       -
           version = "1.9.1";

     

       72
       72
       +
           version = "1.10.0";

     

       73
       73
        
         };

     

       74
       74
        
         rubocop-ast = {

     

       75
       75
        
           dependencies = ["parser"];

+4 -4

pkgs/misc/emulators/ryujinx/default.nix

···

       15
       15
        
         ];

     

       16
       16
        
       in stdenv.mkDerivation rec {

     

       17
       17
        
         pname = "ryujinx";

     

       18
       18
       -
         version = "1.0.6498"; # Versioning is based off of the official appveyor builds: https://ci.appveyor.com/project/gdkchan/ryujinx

     

       18
       18
       +
         version = "1.0.6574"; # Versioning is based off of the official appveyor builds: https://ci.appveyor.com/project/gdkchan/ryujinx

     

       19
       19
        
       

     

       20
       20
        
         src = fetchFromGitHub {

     

       21
       21
        
           owner = "Ryujinx";

     

       22
       22
        
           repo = "Ryujinx";

     

       23
       23
       -
           rev = "67033ed8e05eb70860ac6af2b83deab0256c11eb";

     

       24
       24
       -
           sha256 = "1lg0cybbrf0x3jl10jwdwcg1zyhxsqfdnwnsvdm1lah75xg15ymw";

     

       23
       23
       +
           rev = "80ed8596c165127fb52026c697a9b6b515dabbd4";

     

       24
       24
       +
           sha256 = "0jhrl8g9fbz3w2hzmy9jm22cvjfa0x5vh3912rz1rvnd41qb9vs8";

     

       25
       25
        
         };

     

       26
       26
        
       

     

       27
       27
        
         nativeBuildInputs = [ dotnet-sdk_5 dotnetPackages.Nuget cacert makeWrapper wrapGAppsHook gobject-introspection gdk-pixbuf ];

     
···

       44
       44
        
       

     

       45
       45
        
           export HOME=$(mktemp -d)

     

       46
       46
        
           export DOTNET_CLI_TELEMETRY_OPTOUT=1

     

       47
       47
       -
           export DOTNET_SKIP_FIRST_TIME_EXPERIENCE=1

     

       47
       47
       +
           export DOTNET_NOLOGO=1

     

       48
       48
        
       

     

       49
       49
        
           nuget sources Add -Name nixos -Source "$PWD/nixos"

     

       50
       50
        
           nuget init "$nugetDeps" "$PWD/nixos"

+3 -3

pkgs/tools/admin/clair/default.nix

···

       2
       2
        
       

     

       3
       3
        
       buildGoModule rec {

     

       4
       4
        
         pname = "clair";

     

       5
       5
       -
         version = "4.0.0";

     

       5
       5
       +
         version = "4.0.1";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "quay";

     

       9
       9
        
           repo = pname;

     

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

     

       11
       11
       -
           sha256 = "10kgg2i5yzdfhylrdkmh8rsc4cgdnhcgfa8fa4dm8m3licjciwam";

     

       11
       11
       +
           sha256 = "sha256-FJqUYQDDOuO0EcZ8+el/MUcJJzWL7vgGhEFo7v4HpOw=";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
       -
         vendorSha256 = "1l3b86f5xmyc6lskvb4ab30adcgzb69ayccc0wcz2f28sda3i80r";

     

       14
       14
       +
         vendorSha256 = "sha256-CO4U8uSQeHXLPj5PH/SsOI/LjT2Rs/mBHsvNTudx72I=";

     

       15
       15
        
       

     

       16
       16
        
         doCheck = false;

     

       17
       17

+9 -3

pkgs/tools/admin/google-cloud-sdk/default.nix

···

       21
       21
        
         sources = name: system: {

     

       22
       22
        
           x86_64-darwin = {

     

       23
       23
        
             url = "${baseUrl}/${name}-darwin-x86_64.tar.gz";

     

       24
       24
       -
             sha256 = "09pv1xvycgfai151z6kbsggyldcd3cx6x1p04dcim2xrawqvng6s";

     

       24
       24
       +
             sha256 = "135xbaz6q4565mklxjmm4mybm5qayvz34m0bdg609597kxw6l97j";

     

       25
       25
        
           };

     

       26
       26
        
       

     

       27
       27
        
           x86_64-linux = {

     

       28
       28
        
             url = "${baseUrl}/${name}-linux-x86_64.tar.gz";

     

       29
       29
       -
             sha256 = "1iybbvxjny33mw3h2f81fdvsvp65xa62c2qrzjv8hkrqkw69ckrp";

     

       29
       29
       +
             sha256 = "1i4cp6kyqbqj0fnmwx11bq6a1k4hrhyxz9qifr1qjfi7n8ybqrqy";

     

       30
       30
        
           };

     

       31
       31
        
         }.${system};

     

       32
       32
        
       

     

       33
       33
        
       in stdenv.mkDerivation rec {

     

       34
       34
        
         pname = "google-cloud-sdk";

     

       35
       35
       -
         version = "325.0.0";

     

       35
       35
       +
         version = "327.0.0";

     

       36
       36
        
       

     

       37
       37
        
         src = fetchurl (sources "${pname}-${version}" stdenv.hostPlatform.system);

     

       38
       38
        
       

     
···

       41
       41
        
         nativeBuildInputs = [ jq ];

     

       42
       42
        
       

     

       43
       43
        
         patches = [

     

       44
       44
       +
           # For kubectl configs, don't store the absolute path of the `gcloud` binary as it can be garbage-collected

     

       44
       45
        
           ./gcloud-path.patch

     

       46
       46
       +
           # Disable checking for updates for the package

     

       45
       47
        
           ./gsutil-disable-updates.patch

     

       46
       48
        
         ];

     

       47
       49
        
       

     

       48
       50
        
         installPhase = ''

     

       51
       51
       +
           runHook preInstall

     

       52
       52
       +
       

     

       49
       53
        
           mkdir -p $out/google-cloud-sdk

     

       50
       54
        
           cp -R * .install $out/google-cloud-sdk/

     

       51
       55
        
       

     
···

       91
       95
        
             jq -c . $path > $path.min

     

       92
       96
        
             mv $path.min $path

     

       93
       97
        
           done

     

       98
       98
       +
       

     

       99
       99
       +
           runHook postInstall

     

       94
       100
        
         '';

     

       95
       101
        
       

     

       96
       102
        
         meta = with lib; {

+3 -3

pkgs/tools/misc/dua/default.nix

···

       2
       2
        
       

     

       3
       3
        
       rustPlatform.buildRustPackage rec {

     

       4
       4
        
         pname = "dua";

     

       5
       5
       -
         version = "2.10.10";

     

       5
       5
       +
         version = "2.11.0";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "Byron";

     

       9
       9
        
           repo = "dua-cli";

     

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

     

       11
       11
       -
           sha256 = "sha256-Rt+60j1+uwL6g4HGc+xdUzGK6nanGfRYbekO54iKsPE=";

     

       11
       11
       +
           sha256 = "sha256-c+3zB0bxohQQsOjcTLHgRQamJfm7iUdz79t8q8wAFL8=";

     

       12
       12
        
           # Remove unicode file names which leads to different checksums on HFS+

     

       13
       13
        
           # vs. other filesystems because of unicode normalisation.

     

       14
       14
        
           extraPostFetch = ''

     
···

       16
       16
        
           '';

     

       17
       17
        
         };

     

       18
       18
        
       

     

       19
       19
       -
         cargoSha256 = "sha256-6L1J5RHI657Z03rMmhwEzgpQ0//dykqGi8bI2Enc3N8=";

     

       19
       19
       +
         cargoSha256 = "sha256-ORkj6T9O/NKuaILm5NFGePYxKMaCAAydascelaEvYVw=";

     

       20
       20
        
       

     

       21
       21
        
         doCheck = false;

     

       22
       22

+9 -3

pkgs/tools/misc/fend/default.nix

···

       2
       2
        
       

     

       3
       3
        
       rustPlatform.buildRustPackage rec {

     

       4
       4
        
         pname = "fend";

     

       5
       5
       -
         version = "0.1.13";

     

       5
       5
       +
         version = "0.1.14";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "printfn";

     

       9
       9
        
           repo = pname;

     

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

     

       11
       11
       -
           sha256 = "sha256-dz6vGRsWc7ubc/drj2Qw/of8AciPgVzc4++Eozg0Luo=";

     

       11
       11
       +
           sha256 = "sha256-zKjYUkkm15YRF0YFJKi2A6twvmHuEyxdWcNs37r2dJg=";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
       -
         cargoSha256 = "sha256-/HBTmLZLhv89mvIVLocw9XbfOgxh9KsjA6KT60IuJeA=";

     

       14
       14
       +
         cargoSha256 = "sha256-e95DRhD22zvizUJOM2It45Bx05iK3KtaMgFPkMbR7iI=";

     

       15
       15
       +
       

     

       16
       16
       +
         doInstallCheck = true;

     

       17
       17
       +
       

     

       18
       18
       +
         installCheckPhase = ''

     

       19
       19
       +
           [[ "$($out/bin/fend "1 km to m")" = "1000 m" ]]

     

       20
       20
       +
         '';

     

       15
       21
        
       

     

       16
       22
        
         meta = with lib; {

     

       17
       23
        
           description = "Arbitrary-precision unit-aware calculator";

+25

pkgs/tools/misc/savepagenow/default.nix

···

       1
       1
       +
       { lib, python3Packages, fetchFromGitHub }:

     

       2
       2
       +
       

     

       3
       3
       +
       python3Packages.buildPythonApplication rec {

     

       4
       4
       +
         pname = "savepagenow";

     

       5
       5
       +
         version = "1.1.1";

     

       6
       6
       +
       

     

       7
       7
       +
         src = fetchFromGitHub {

     

       8
       8
       +
           owner = "pastpages";

     

       9
       9
       +
           repo = pname;

     

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

     

       11
       11
       +
           sha256 = "1lz6rc47cds9rb35jdf8n13gr61wdkh5jqzx4skikm1yrqkwjyhm";

     

       12
       12
       +
         };

     

       13
       13
       +
       

     

       14
       14
       +
         propagatedBuildInputs = with python3Packages; [ click requests ];

     

       15
       15
       +
       

     

       16
       16
       +
         # requires network access

     

       17
       17
       +
         doCheck = false;

     

       18
       18
       +
       

     

       19
       19
       +
         meta = with lib; {

     

       20
       20
       +
           description = "A simple Python wrapper for archive.org's \"Save Page Now\" capturing service";

     

       21
       21
       +
           homepage = "https://github.com/pastpages/savepagenow";

     

       22
       22
       +
           license = licenses.mit;

     

       23
       23
       +
           maintainers = with maintainers; [ SuperSandro2000 ];

     

       24
       24
       +
         };

     

       25
       25
       +
       }

+3 -3

pkgs/tools/misc/skim/default.nix

···

       2
       2
        
       

     

       3
       3
        
       rustPlatform.buildRustPackage rec {

     

       4
       4
        
         pname = "skim";

     

       5
       5
       -
         version = "0.9.3";

     

       5
       5
       +
         version = "0.9.4";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchCrate {

     

       8
       8
        
           inherit pname version;

     

       9
       9
       -
           sha256 = "026mgqcp9sg6wwikghrc3rgh5p6wdbnvav5pb3xvs79lj85d5ga7";

     

       9
       9
       +
           sha256 = "0yvjzmz2vqc63l8911jflqf5aww7wxsav2yal5wg9ci9hzq6dl7j";

     

       10
       10
        
         };

     

       11
       11
        
       

     

       12
       12
        
         outputs = [ "out" "vim" ];

     

       13
       13
        
       

     

       14
       14
       -
         cargoSha256 = "07bs23x2vxzlrca5swwq8khmd9fbdhlhm0avwp9y231df6xdi2ys";

     

       14
       14
       +
         cargoSha256 = "0xh4f8c62kzj2fx7hyhdy13zhay13a6d2d7i9yz0n40dfgf70qx0";

     

       15
       15
        
       

     

       16
       16
        
         postPatch = ''

     

       17
       17
        
           sed -i -e "s|expand('<sfile>:h:h')|'$out'|" plugin/skim.vim

+3 -3

pkgs/tools/misc/topgrade/default.nix

···

       2
       2
        
       

     

       3
       3
        
       rustPlatform.buildRustPackage rec {

     

       4
       4
        
         pname = "topgrade";

     

       5
       5
       -
         version = "6.5.0";

     

       5
       5
       +
         version = "6.5.1";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "r-darwish";

     

       9
       9
        
           repo = pname;

     

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

     

       11
       11
       -
           sha256 = "sha256-O2k9eUs+aopwtT/DXYIv9pc9z8W4K6cXUE6diqNDTrg=";

     

       11
       11
       +
           sha256 = "sha256-5S9mKmnrycrL7DFq8duWVbzEHQfiXAXQYcc3bdiVu1k=";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
       -
         cargoSha256 = "1yjhphw680cf93lgknksa67k0w0rhq6s3jinyn649wd71gbc5656";

     

       14
       14
       +
         cargoSha256 = "0sbkqdwfsfb7q52a9vh5lmggrc8ny2l0xr4qx3m42xm0h64f3y6n";

     

       15
       15
        
       

     

       16
       16
        
         buildInputs = lib.optional stdenv.isDarwin Foundation;

     

       17
       17

pkgs/tools/networking/xh/default.nix

···

       25
       25
        
         meta = with lib; {

     

       26
       26
        
           description = "Yet another HTTPie clone in Rust";

     

       27
       27
        
           homepage = "https://github.com/ducaale/xh";

     

       28
       28
       +
           changelog = "https://github.com/ducaale/xh/blob/v${version}/CHANGELOG.md";

     

       28
       29
        
           license = licenses.mit;

     

       29
       30
        
           maintainers = with maintainers; [ payas SuperSandro2000 ];

     

       30
       31
        
         };

pkgs/top-level/aliases.nix

···

       113
       113
        
         cpp_ethereum = throw "cpp_ethereum has been removed; abandoned upstream."; # added 2020-11-30

     

       114
       114
        
         cryptol = throw "cryptol was removed due to prolonged broken build"; # added 2020-08-21

     

       115
       115
        
         cpp-gsl = microsoft_gsl; # added 2019-05-24

     

       116
       116
       +
         cudatoolkit_6 = throw "cudatoolkit_6 has been removed in favor of newer versions"; # added 2021-02-14

     

       117
       117
       +
         cudatoolkit_65 = throw "cudatoolkit_65 has been removed in favor of newer versions"; # added 2021-02-14

     

       118
       118
       +
         cudatoolkit_7 = throw "cudatoolkit_7 has been removed in favor of newer versions"; # added 2021-02-14

     

       119
       119
       +
         cudatoolkit_7_5 = throw "cudatoolkit_7_5 has been removed in favor of newer versions"; # added 2021-02-14

     

       120
       120
       +
         cudatoolkit_8 = throw "cudatoolkit_8 has been removed in favor of newer versions"; # added 2021-02-14

     

       121
       121
       +
         cudnn_cudatoolkit_7 = throw "cudnn_cudatoolkit_7 has been removed in favor of newer versions"; # added 2021-02-14

     

       122
       122
       +
         cudnn_cudatoolkit_7_5 = throw "cudnn_cudatoolkit_7_5 has been removed in favor of newer versions"; # added 2021-02-14

     

       123
       123
       +
         cudnn6_cudatoolkit_8 = throw "cudnn6_cudatoolkit_8 has been removed in favor of newer versions"; # added 2021-02-14

     

       124
       124
       +
         cudnn_cudatoolkit_8 = throw "cudnn_cudatoolkit_8 has been removed in favor of newer versions"; # added 2021-02-14

     

       116
       125
        
         cupsBjnp = cups-bjnp; # added 2016-01-02

     

       117
       126
        
         cups_filters = cups-filters; # added 2016-08

     

       118
       127
        
         cups-googlecloudprint = throw "Google Cloudprint is officially discontinued since Jan 2021, more info https://support.google.com/chrome/a/answer/9633006";

+4 -9

pkgs/top-level/all-packages.nix

···

       3398
       3398
        
       

     

       3399
       3399
        
         cudaPackages = recurseIntoAttrs (callPackage ../development/compilers/cudatoolkit {});

     

       3400
       3400
        
         inherit (cudaPackages)

     

       3401
       3401
       -
           cudatoolkit_6

     

       3402
       3402
       -
           cudatoolkit_6_5

     

       3403
       3403
       -
           cudatoolkit_7

     

       3404
       3404
       -
           cudatoolkit_7_5

     

       3405
       3405
       -
           cudatoolkit_8

     

       3406
       3401
        
           cudatoolkit_9

     

       3407
       3402
        
           cudatoolkit_9_0

     

       3408
       3403
        
           cudatoolkit_9_1

     
···

       3420
       3415
        
       

     

       3421
       3416
        
         cudnnPackages = callPackages ../development/libraries/science/math/cudnn { };

     

       3422
       3417
        
         inherit (cudnnPackages)

     

       3423
       3423
       -
           cudnn_cudatoolkit_7

     

       3424
       3424
       -
           cudnn_cudatoolkit_7_5

     

       3425
       3425
       -
           cudnn6_cudatoolkit_8

     

       3426
       3426
       -
           cudnn_cudatoolkit_8

     

       3427
       3418
        
           cudnn_cudatoolkit_9

     

       3428
       3419
        
           cudnn_cudatoolkit_9_0

     

       3429
       3420
        
           cudnn_cudatoolkit_9_1

     
···

       20781
       20772
        
       

     

       20782
       20773
        
         sarasa-gothic = callPackage ../data/fonts/sarasa-gothic { };

     

       20783
       20774
        
       

     

       20775
       20775
       +
         savepagenow = callPackage ../tools/misc/savepagenow { };

     

       20776
       20776
       +
       

     

       20784
       20777
        
         scheme-manpages = callPackage ../data/documentation/scheme-manpages { };

     

       20785
       20778
        
       

     

       20786
       20779
        
         scowl = callPackage ../data/misc/scowl { };

     
···

       23237
       23230
        
         k9s = callPackage ../applications/networking/cluster/k9s { };

     

       23238
       23231
        
       

     

       23239
       23232
        
         popeye = callPackage ../applications/networking/cluster/popeye { };

     

       23233
       23233
       +
       

     

       23234
       23234
       +
         kube-capacity = callPackage ../applications/networking/cluster/kube-capacity { };

     

       23240
       23235
        
       

     

       23241
       23236
        
         fluxctl = callPackage ../applications/networking/cluster/fluxctl { };

     

       23242
       23237

+23 -5

pkgs/top-level/ocaml-packages.nix

···

       82
       82
        
       

     

       83
       83
        
           ca-certs = callPackage ../development/ocaml-modules/ca-certs { };

     

       84
       84
        
       

     

       85
       85
       +
           carton = callPackage ../development/ocaml-modules/carton { };

     

       86
       86
       +
       

     

       87
       87
       +
           carton-git = callPackage ../development/ocaml-modules/carton/git.nix { };

     

       88
       88
       +
       

     

       89
       89
       +
           carton-lwt = callPackage ../development/ocaml-modules/carton/lwt.nix {

     

       90
       90
       +
             git-binary = pkgs.git;

     

       91
       91
       +
           };

     

       92
       92
       +
       

     

       85
       93
        
           camlidl = callPackage ../development/tools/ocaml/camlidl { };

     

       86
       94
        
       

     

       87
       95
        
           camlp4 =

     
···

       391
       399
        
       

     

       392
       400
        
           imagelib = callPackage ../development/ocaml-modules/imagelib { };

     

       393
       401
        
       

     

       394
       394
       -
           imagelib-unix = callPackage ../development/ocaml-modules/imagelib/unix.nix { };

     

       395
       395
       -
       

     

       396
       402
        
           inotify = callPackage ../development/ocaml-modules/inotify { };

     

       397
       403
        
       

     

       398
       404
        
           integers = callPackage ../development/ocaml-modules/integers { };

     
···

       425
       431
        
             git-binary = pkgs.git;

     

       426
       432
        
           };

     

       427
       433
        
       

     

       428
       428
       -
           git-http = callPackage ../development/ocaml-modules/git-http { };

     

       434
       434
       +
           git-cohttp = callPackage ../development/ocaml-modules/git/cohttp.nix { };

     

       429
       435
        
       

     

       430
       430
       -
           git-unix = callPackage ../development/ocaml-modules/git-unix {

     

       436
       436
       +
           git-cohttp-unix = callPackage ../development/ocaml-modules/git/cohttp-unix.nix { };

     

       437
       437
       +
       

     

       438
       438
       +
           git-cohttp-mirage = callPackage ../development/ocaml-modules/git/cohttp-mirage.nix { };

     

       439
       439
       +
       

     

       440
       440
       +
           git-unix = callPackage ../development/ocaml-modules/git/unix.nix {

     

       431
       441
        
             git-binary = pkgs.git;

     

       432
       442
        
           };

     

       433
       443
        
       

     
···

       464
       474
        
       

     

       465
       475
        
           irmin-chunk = callPackage ../development/ocaml-modules/irmin/chunk.nix { };

     

       466
       476
        
       

     

       477
       477
       +
           irmin-containers = callPackage ../development/ocaml-modules/irmin/containers.nix { };

     

       478
       478
       +
       

     

       467
       479
        
           irmin-fs = callPackage ../development/ocaml-modules/irmin/fs.nix { };

     

       468
       480
        
       

     

       469
       481
        
           irmin-git = callPackage ../development/ocaml-modules/irmin/git.nix { };

     
···

       472
       484
        
       

     

       473
       485
        
           irmin-http = callPackage ../development/ocaml-modules/irmin/http.nix { };

     

       474
       486
        
       

     

       475
       475
       -
           irmin-mem = callPackage ../development/ocaml-modules/irmin/mem.nix { };

     

       487
       487
       +
           irmin-layers = callPackage ../development/ocaml-modules/irmin/layers.nix { };

     

       488
       488
       +
       

     

       489
       489
       +
           irmin-mirage = callPackage ../development/ocaml-modules/irmin/mirage.nix { };

     

       490
       490
       +
       

     

       491
       491
       +
           irmin-mirage-git = callPackage ../development/ocaml-modules/irmin/mirage-git.nix { };

     

       492
       492
       +
       

     

       493
       493
       +
           irmin-mirage-graphql = callPackage ../development/ocaml-modules/irmin/mirage-graphql.nix { };

     

       476
       494
        
       

     

       477
       495
        
           irmin-pack = callPackage ../development/ocaml-modules/irmin/pack.nix { };

     

       478
       496

pkgs/top-level/perl-packages.nix

···

       16629
       16629
        
             description = "Indent and reformat perl scripts";

     

       16630
       16630
        
             license = lib.licenses.gpl2Plus;

     

       16631
       16631
        
           };

     

       16632
       16632
       +
           nativeBuildInputs = lib.optional stdenv.isDarwin shortenPerlShebang;

     

       16633
       16633
       +
           postInstall = lib.optionalString stdenv.isDarwin ''

     

       16634
       16634
       +
             shortenPerlShebang $out/bin/perltidy

     

       16635
       16635
       +
           '';

     

       16632
       16636
        
         };

     

       16633
       16637
        
       

     

       16634
       16638
        
         PHPSerialization = buildPerlPackage {