Merge master into staging-next

lib/fixed-points.nix

···
   # think of it as an infix operator `g extends f` that mimics the syntax from
   # Java. It may seem counter-intuitive to have the "base class" as the second
   # argument, but it's nice this way if several uses of `extends` are cascaded.
+  #
+  # To get a better understanding how `extends` turns a function with a fix
+  # point (the package set we start with) into a new function with a different fix
+  # point (the desired packages set) lets just see, how `extends g f`
+  # unfolds with `g` and `f` defined above:
+  #
+  # extends g f = self: let super = f self; in super // g self super;
+  #             = self: let super = { foo = "foo"; bar = "bar"; foobar = self.foo + self.bar; }; in super // g self super
+  #             = self: { foo = "foo"; bar = "bar"; foobar = self.foo + self.bar; } // g self { foo = "foo"; bar = "bar"; foobar = self.foo + self.bar; }
+  #             = self: { foo = "foo"; bar = "bar"; foobar = self.foo + self.bar; } // { foo = "foo" + " + "; }
+  #             = self: { foo = "foo + "; bar = "bar"; foobar = self.foo + self.bar; }
+  #
   extends = f: rattrs: self: let super = rattrs self; in super // f self super;
 
   # Compose two extending functions of the type expected by 'extends'

lib/systems/parse.nix

···
     aarch64  = { bits = 64; significantByte = littleEndian; family = "arm"; version = "8"; };
     aarch64_be = { bits = 64; significantByte = bigEndian; family = "arm"; version = "8"; };
 
+    i386     = { bits = 32; significantByte = littleEndian; family = "x86"; };
+    i486     = { bits = 32; significantByte = littleEndian; family = "x86"; };
+    i586     = { bits = 32; significantByte = littleEndian; family = "x86"; };
     i686     = { bits = 32; significantByte = littleEndian; family = "x86"; };
     x86_64   = { bits = 64; significantByte = littleEndian; family = "x86"; };
 

maintainers/maintainer-list.nix

···
     github = "sauyon";
     name = "Sauyon Lee";
   };
+  sboosali = {
+    email = "[e-mail]";
+    github = "sboosali";
+    name = "Sam Boosalis";
+  };
   schmitthenner = {
     email = "[e-mail]";
     github = "fkz";

nixos/modules/config/networking.nix

···
               # a collision with an apparently unrelated environment
               # variable with the same name exported by dhcpcd.
               interface_order='lo lo[0-9]*'
+            '' + optionalString config.services.nscd.enable ''
+              # Invalidate the nscd cache whenever resolv.conf is
+              # regenerated.
+              libc_restart='${pkgs.systemd}/bin/systemctl try-restart --no-block nscd.service 2> /dev/null'
             '' + optionalString (length resolvconfOptions > 0) ''
               # Options as described in resolv.conf(5)
               resolv_conf_options='${concatStringsSep " " resolvconfOptions}'

nixos/modules/module-list.nix

···
   ./programs/less.nix
   ./programs/light.nix
   ./programs/mosh.nix
+  ./programs/mininet.nix
   ./programs/mtr.nix
   ./programs/nano.nix
   ./programs/npm.nix

nixos/modules/programs/mininet.nix

···
+# Global configuration for mininet
+# kernel must have NETNS/VETH/SCHED
+{ config, lib, pkgs, ... }:
+
+with lib;
+
+let
+  cfg  = config.programs.mininet;
+
+  generatedPath = with pkgs; makeSearchPath "bin"  [
+    iperf ethtool iproute socat
+  ];
+
+  pyEnv = pkgs.python.withPackages(ps: [ ps.mininet-python ]);
+
+  mnexecWrapped = pkgs.runCommand "mnexec-wrapper"
+    { buildInputs = [ pkgs.makeWrapper pkgs.pythonPackages.wrapPython ]; }
+    ''
+      makeWrapper ${pkgs.mininet}/bin/mnexec \
+        $out/bin/mnexec \
+        --prefix PATH : "${generatedPath}"
+
+      ln -s ${pyEnv}/bin/mn $out/bin/mn
+
+      # mn errors out without a telnet binary
+      # pkgs.telnet brings an undesired ifconfig into PATH see #43105
+      ln -s ${pkgs.telnet}/bin/telnet $out/bin/telnet
+    '';
+in
+{
+  options.programs.mininet.enable = mkEnableOption "Mininet";
+
+  config = mkIf cfg.enable {
+
+    virtualisation.vswitch.enable = true;
+
+    environment.systemPackages = [ mnexecWrapped ];
+  };
+}

nixos/modules/services/desktops/gnome3/seahorse.nix

···
 
   config = mkIf config.services.gnome3.seahorse.enable {
 
-    environment.systemPackages = [ pkgs.gnome3.seahorse ];
+    environment.systemPackages = [ pkgs.gnome3.seahorse pkgs.gnome3.dconf ];
 
     services.dbus.packages = [ pkgs.gnome3.seahorse ];
 

nixos/modules/services/monitoring/netdata.nix

···
           message = "Cannot specify both config and configText";
         }
       ];
+
+    systemd.tmpfiles.rules = [
+      "d /var/cache/netdata 0755 ${cfg.user} ${cfg.group} -"
+      "Z /var/cache/netdata - ${cfg.user} ${cfg.group} -"
+      "d /var/log/netdata 0755 ${cfg.user} ${cfg.group} -"
+      "Z /var/log/netdata - ${cfg.user} ${cfg.group} -"
+      "d /var/lib/netdata 0755 ${cfg.user} ${cfg.group} -"
+      "Z /var/lib/netdata - ${cfg.user} ${cfg.group} -"
+      "d /etc/netdata 0755 ${cfg.user} ${cfg.group} -"
+      "Z /etc/netdata - ${cfg.user} ${cfg.group} -"
+    ];
     systemd.services.netdata = {
       description = "Real time performance monitoring";
       after = [ "network.target" ];
       wantedBy = [ "multi-user.target" ];
       path = (with pkgs; [ gawk curl ]) ++ lib.optional cfg.python.enable
         (pkgs.python3.withPackages cfg.python.extraPackages);
-      preStart = concatStringsSep "\n" (map (dir: ''
-        mkdir -vp ${dir}
-        chmod 750 ${dir}
-        chown -R ${cfg.user}:${cfg.group} ${dir}
-        '') [ "/var/cache/netdata"
-              "/var/log/netdata"
-              "/var/lib/netdata" ]);
       serviceConfig = {
         User = cfg.user;
         Group = cfg.group;

pkgs/applications/altcoins/parity/beta.nix

···
 let
-  version     = "2.1.3";
-  sha256      = "0il18r229r32jzwsjksp8cc63rp6cf6c0j5dvbfzrnv1zndw0cg3";
-  cargoSha256 = "08dyb0lgf66zfq9xmfkhcn6rj070d49dm0rjl3v39sfag6sryz20";
+  version     = "2.2.1";
+  sha256      = "1m65pks2jk83j82f1i901p03qb54xhcp6gfjngcm975187zzvmcq";
+  cargoSha256 = "1mf1jgphwvhlqkvzrgbhnqfyqgf3ljc1l9zckyilzmw5k4lf4g1w";
   patches     = [
-    ./patches/vendored-sources-2.1.patch
+    ./patches/vendored-sources-2.2.patch
   ];
 in
   import ./parity.nix { inherit version sha256 cargoSha256 patches; }

pkgs/applications/altcoins/parity/default.nix

···
 let
-  version     = "2.0.8";
-  sha256      = "1bz6dvx8wxhs3g447s62d9091sard2x7w2zd6iy7hf76wg0p73hr";
-  cargoSha256 = "0wj93md87fr7a9ag73h0rd9xxqscl0lhbj3g3kvnqrqz9xxajing";
-  patches     = [ ./patches/vendored-sources-2.0.patch ];
+  version     = "2.1.6";
+  sha256      = "0njkypszi0fjh9y0zfgxbycs4c1wpylk7wx6xn1pp6gqvvri6hav";
+  cargoSha256 = "116sj7pi50k5gb1i618g4pgckqaf8kb13jh2a3shj2kwywzzcgjs";
+  patches     = [ ./patches/vendored-sources-2.1.patch ];
 in
   import ./parity.nix { inherit version sha256 cargoSha256 patches; }

pkgs/applications/altcoins/parity/patches/vendored-sources-2.0.patch pkgs/applications/altcoins/parity/patches/vendored-sources-2.2.patch

···
 +
 +[source."https://github.com/paritytech/jsonrpc.git"]
 +git = "https://github.com/paritytech/jsonrpc.git"
-+branch = "parity-1.11"
++branch = "parity-2.2"
 +replace-with = "vendored-sources"
 +
 +[source."https://github.com/paritytech/libusb-rs"]

pkgs/applications/altcoins/parity/patches/vendored-sources-2.1.patch

···
 +
 +[source."https://github.com/nikvolf/parity-tokio-ipc"]
 +git = "https://github.com/nikvolf/parity-tokio-ipc"
-+rev = "7c9bbe3bc45d8e72a92b0951acc877da228abd50"
++rev = "c0f80b40399d7f08ef1e6869569640eb28645f56"
 +replace-with = "vendored-sources"
 +
 +[source."https://github.com/nikvolf/tokio-named-pipes"]

pkgs/applications/audio/traverso/default.nix

···
+{ stdenv, fetchurl, cmake, pkgconfig
+, alsaLib, fftw, flac, lame, libjack2, libmad, libpulseaudio
+, libsamplerate, libsndfile, libvorbis, portaudio, qtbase, wavpack
+}:
+stdenv.mkDerivation rec {
+  name = "traverso-${version}";
+  version = "0.49.5";
+
+  src = fetchurl {
+    url = "http://traverso-daw.org/traverso-0.49.5.tar.gz";
+    sha256 = "169dsqrf807ciavrd82d3iil0xy0r3i1js08xshcrn80ws9hv63m";
+  };
+
+  nativeBuildInputs = [ cmake pkgconfig ];
+  buildInputs = [ alsaLib fftw flac.dev libjack2 lame
+                  libmad libpulseaudio libsamplerate.dev libsndfile.dev libvorbis
+                  portaudio qtbase wavpack ];
+
+  cmakeFlags = [ "-DWANT_PORTAUDIO=1" "-DWANT_PULSEAUDIO=1" "-DWANT_MP3_ENCODE=1" "-DWANT_LV2=0" ];
+
+  enableParallelBuilding = true;
+  hardeningDisable = [ "format" ];
+
+  meta = with stdenv.lib; {
+    description = "Cross-platform multitrack audio recording and audio editing suite";
+    homepage = http://traverso-daw.org/;
+    license = with licenses; [ gpl2Plus lgpl21Plus ];
+    platforms = platforms.all;
+    maintainers = with maintainers; [ coconnor ];
+  };
+}

pkgs/applications/editors/mindforger/build.patch

···
+diff --git a/app/app.pro b/app/app.pro
+index 4d47065..a39a320 100644
+--- a/app/app.pro
++++ b/app/app.pro
+@@ -18,6 +18,8 @@
+ TARGET = mindforger
+ TEMPLATE = app
+ 
++include(../config.pri)
++
+ QT += widgets
+ 
+ mfner {
+@@ -297,7 +299,7 @@ RESOURCES += \
+ # See http://doc.qt.io/qt-5/qmake-advanced-usage.html
+ 
+ binfile.files += mindforger
+-binfile.path = /usr/bin/
++binfile.path = $$PREFIX/bin/
+ INSTALLS += binfile
+ 
+ # ########################################
+diff --git a/config.pri b/config.pri
+new file mode 100644
+index 0000000..ce05df1
+--- /dev/null
++++ b/config.pri
+@@ -0,0 +1,3 @@
++isEmpty(PREFIX) {
++ PREFIX = /usr
++}
+diff --git a/deps/discount/discount.pro b/deps/discount/discount.pro
+index a8dfe35..ec16468 100644
+--- a/deps/discount/discount.pro
++++ b/deps/discount/discount.pro
+@@ -5,6 +5,8 @@
+ # Webpage: http://www.pell.portland.or.us/~orc/Code/discount/
+ #
+ 
++include(../../config.pri)
++
+ QT       -= core gui
+ 
+ TARGET = discount
+@@ -46,7 +48,7 @@ unix:!symbian {
+     maemo5 {
+         target.path = /opt/usr/lib
+     } else {
+-        target.path = /usr/lib
++        target.path = $$PREFIX/lib
+     }
+     INSTALLS += target
+ }
+diff --git a/mindforger.pro b/mindforger.pro
+index ae627f2..0953856 100644
+--- a/mindforger.pro
++++ b/mindforger.pro
+@@ -32,6 +32,8 @@ TEMPLATE = subdirs
+ 
+ SUBDIRS = deps lib app
+ 
++include(config.pri)
++
+ # build dependencies
+ lib.depends = deps
+ app.depends = lib
+@@ -44,20 +46,20 @@ app.depends = lib
+ #IMPORTANT: binfile MUST be specified in app/app.pro (project next to/that builds binary)
+ 
+ docfiles.files += doc/*
+-docfiles.path = /usr/share/doc/mindforger/
++docfiles.path = $$PREFIX/share/doc/mindforger/
+ INSTALLS += docfiles
+ 
+ manfiles.files += man/*
+-manfiles.path = /usr/share/man/man1/
++manfiles.path = $$PREFIX/share/man/man1/
+ INSTALLS += manfiles
+ 
+ iconfiles.files += app/resources/icons/*
+-iconfiles.path = /usr/share/icons/mindforger/
++iconfiles.path = $$PREFIX/share/icons/mindforger/
+ INSTALLS += iconfiles
+ 
+ # experiment w/ file
+ shortcutfiles.files += app/resources/gnome-shell/mindforger.desktop
+-shortcutfiles.path = /usr/share/applications/
++shortcutfiles.path = $$PREFIX/share/applications/
+ INSTALLS += shortcutfiles
+ 
+ # eof

pkgs/applications/editors/mindforger/default.nix

···
+{ stdenv, fetchurl, qmake, qtbase, qtwebkit }:
+
+stdenv.mkDerivation rec {
+  name = "mindforger-${version}";
+  version = "1.48.2";
+
+  src = fetchurl {
+    url = "https://github.com/dvorka/mindforger/releases/download/1.48.0/mindforger_${version}.tgz";
+    sha256 = "1wlrl8hpjcpnq098l3n2d1gbhbjylaj4z366zvssqvmafr72iyw4";
+  };
+
+  nativeBuildInputs = [ qmake ] ;
+  buildInputs = [ qtbase qtwebkit ] ;
+
+  doCheck = true;
+
+  enableParallelBuilding = true ;
+
+  patches = [ ./build.patch ] ;
+
+  postPatch = ''
+    substituteInPlace deps/discount/version.c.in --subst-var-by TABSTOP 4
+    substituteInPlace app/resources/gnome-shell/mindforger.desktop --replace /usr "$out"
+  '';
+
+  preConfigure = ''
+    export AC_PATH="$PATH"
+    pushd deps/discount
+    ./configure.sh
+    popd
+  '';
+
+  qmakeFlags = [ "-r mindforger.pro" "CONFIG+=mfnoccache" ] ;
+
+  meta = with stdenv.lib; {
+    description = "Thinking Notebook & Markdown IDE";
+    longDescription = ''
+     MindForger is actually more than an editor or IDE - it's human
+     mind inspired personal knowledge management tool
+    '';
+    homepage = https://www.mindforger.com;
+    license = licenses.gpl2Plus;
+    platforms = platforms.all;
+  };
+}

pkgs/applications/graphics/ao/default.nix

···
-{stdenv, fetchgit, cmake, ninja, boost, libpng, glfw3, epoxy, guile, pkgconfig
-, libGLU_combined, libX11, libpthreadstubs, libXau, libXdmcp, libXrandr, libXext
-, libXinerama, libXxf86vm, libXcursor, libXfixes
-}:
-stdenv.mkDerivation rec {
-  version = "0.0pre20160820";
-  name = "ao-${version}";
-
-  nativeBuildInputs = [ pkgconfig ];
-  buildInputs = [
-    cmake ninja boost libpng glfw3 epoxy guile libGLU_combined libX11 
-    libpthreadstubs libXau libXdmcp libXrandr libXext libXinerama libXxf86vm
-    libXcursor libXfixes
-  ];
-
-  src = fetchgit {
-    url = https://github.com/mkeeter/ao;
-    rev = "69fadb81543cc9031e4a7ec2036c7f2ab505a620";
-    sha256 = "1717k72vr0i5j7bvxmd6q16fpvkljnqfa1hr3i4yq8cjdsj69my7";
-  };
-
-  cmakeFlags = "-G Ninja";
-  installPhase = ''
-    ninja install
-    cd ..
-    cp lib/lib* bind/lib* "$out/lib"
-    cp -r bin "$out/bin"
-    mkdir "$out/doc"
-    cp -r doc "$out/doc/ao"
-    cp -r examples "$out/doc/ao/examples"
-    cp -r bind "$out/bind"
-  '';
-  meta = {
-    inherit version;
-    description = ''Homoiconic CAD package'';
-    license = stdenv.lib.licenses.gpl2Plus ; # Some parts can be extracted and used under LGPL2+
-    maintainers = [stdenv.lib.maintainers.raskin];
-    platforms = stdenv.lib.platforms.linux;
-    broken = true; # 2018-04-10
-  };
-}

pkgs/applications/graphics/processing3/default.nix

···
     ${xmlstarlet}/bin/xmlstarlet ed --inplace -P -d '//get[@src="http://download.processing.org/reference.zip"]' build/build.xml
     install -D -m0444 ${fetchurl {
                           url    = http://download.processing.org/reference.zip;
-                          sha256 = "0dli1bdgw8hsx7g7b048ap81v2za9maa6pfcwdqm3qkfypr8q7pr";
+                          sha256 = "0ai0cr62gc7n6y22ki3qibyj1qnlaxv1miqxmmahfk3hpbyfqz9n";
                         }
                        } ./java/reference.zip
 

pkgs/applications/misc/termonad/default.nix

···
+{ stdenv, ghcWithPackages, makeWrapper, packages ? (pkgSet: []) }:
+
+let
+  termonadEnv = ghcWithPackages (self: [ self.termonad ] ++ packages self);
+in stdenv.mkDerivation {
+  name = "termonad-with-packages-${termonadEnv.version}";
+
+  nativeBuildInputs = [ makeWrapper ];
+
+  buildCommand = ''
+    mkdir -p $out/bin $out/share
+    makeWrapper ${termonadEnv}/bin/termonad $out/bin/termonad \
+      --set NIX_GHC "${termonadEnv}/bin/ghc"
+  '';
+
+  # trivial derivation
+  preferLocalBuild = true;
+  allowSubstitutes = false;
+}

pkgs/applications/misc/wtf/default.nix

···
+{ buildGoPackage
+, fetchFromGitHub
+, lib
+}:
+
+buildGoPackage rec {
+  name = "wtf-${version}";
+  version = "0.4.0";
+
+  goPackagePath = "github.com/senorprogrammer/wtf";
+
+  src = fetchFromGitHub {
+    owner = "senorprogrammer";
+    repo = "wtf";
+    rev = "${version}";
+    sha256 = "1vgjqmw27baiq9brmnafic3w3hw11p5qc6ahbdxi5n5n4bx7j6vn";
+  };
+
+  buildFlagsArray = [ "-ldflags=" "-X main.version=${version}" ];
+
+  meta = with lib; {
+    description = "The personal information dashboard for your terminal";
+    homepage = http://wtfutil.com/;
+    license = licenses.mpl20;
+    maintainers = with maintainers; [ kalbasit ];
+    platforms = platforms.linux ++ platforms.darwin;
+  };
+}

pkgs/applications/networking/browsers/brave/default.nix

···
   gdk_pixbuf,
   glib,
   gnome2,
+  gnome3,
   gtk3,
   libuuid,
   libX11,
···
   udev,
   xorg,
   zlib,
-  xdg_utils
+  xdg_utils,
+  wrapGAppsHook
 }:
 
 let rpath = lib.makeLibraryPath [
···
     dontBuild = true;
     dontPatchELF = true;
 
-    nativeBuildInputs = [ dpkg ];
+    nativeBuildInputs = [ dpkg wrapGAppsHook ];
+
+    buildInputs = [ glib gnome3.gsettings_desktop_schemas gnome3.defaultIconTheme ];
 
     unpackPhase = "dpkg-deb --fsys-tarfile $src | tar -x --no-same-permissions --no-same-owner";
 
     installPhase = ''
-        mkdir -p $out
+        mkdir -p $out $out/bin
 
-        cp -R usr/* $out
+        cp -R usr/share $out
         cp -R opt/ $out/opt
 
         export BINARYWRAPPER=$out/opt/brave.com/brave/brave-browser

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

···
 
 stdenv.mkDerivation rec {
   name = "kubetail-${version}";
-  version = "1.6.4";
+  version = "1.6.5";
 
   src = fetchFromGitHub {
     owner = "johanhaleby";
     repo = "kubetail";
     rev = "${version}";
-    sha256 = "13y3g27z2v4jx1cvphcwl0a5xshm6vcqcxasid5sbg6cpwc2xc66";
+    sha256 = "0q8had1bi1769wd6h1c43gq0cvr5qj1fvyglizlyq1gm8qi2dx7n";
   };
 
   installPhase = ''

pkgs/applications/science/misc/netlogo/default.nix

···
+{ jre, stdenv, fetchurl, makeWrapper, makeDesktopItem }:
+
+let
+
+  desktopItem = makeDesktopItem rec {
+    name = "netlogo";
+    exec = name;
+    icon = name;
+    comment = "A multi-agent programmable modeling environment";
+    desktopName = "NetLogo";
+    categories = "Science;";
+  };
+
+in
+
+stdenv.mkDerivation rec {
+  name = "netlogo-${version}";
+  version = "6.0.4";
+
+  src = fetchurl {
+    url = "https://ccl.northwestern.edu/netlogo/${version}/NetLogo-${version}-64.tgz";
+    sha256 = "0dcd9df4dfb218826a74f9df42163fa588908a1dfe58864106936f8dfb76acec";
+  };
+
+  src1 = fetchurl {
+    name = "netlogo.png";
+    url = "https://netlogoweb.org/assets/images/desktopicon.png";
+    sha256 = "1i43lhr31lzva8d2r0dxpcgr58x496gb5vmb0h2da137ayvifar8";
+  };
+
+  nativeBuildInputs = [ makeWrapper ];
+
+  installPhase = ''
+    mkdir -pv $out/share/netlogo $out/share/icons/hicolor/256x256/apps $out/share/applications $out/share/doc
+    cp -rv app $out/share/netlogo
+    cp -v readme.md $out/share/doc/
+
+    # launcher with `cd` is required b/c otherwise the model library isn't usable
+    makeWrapper "${jre}/bin/java" "$out/bin/netlogo" \
+      --run "cd $out/share/netlogo/app" \
+      --add-flags "-jar netlogo-${version}.jar"
+
+    cp $src1 $out/share/icons/hicolor/256x256/apps/netlogo.png
+    cp ${desktopItem}/share/applications/* $out/share/applications
+  '';
+
+  meta = with stdenv.lib; {
+    description = "A multi-agent programmable modeling environment";
+    longDescription = ''
+      NetLogo is a multi-agent programmable modeling environment. It is used by
+      many tens of thousands of students, teachers and researchers worldwide.
+    '';
+    homepage = https://ccl.northwestern.edu/netlogo/index.shtml;
+    license = licenses.gpl2;
+    maintainers = [ maintainers.dpaetzel ];
+    platforms = platforms.linux;
+  };
+}

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

···
 
 buildRustPackage rec {
   name = "pijul-${version}";
-  version = "0.10.0";
+  version = "0.11.0";
 
   src = fetchurl {
     url = "https://pijul.org/releases/${name}.tar.gz";
-    sha256 = "1lkipcp83rfsj9yqddvb46dmqdf2ch9njwvjv8f3g91rmfjcngys";
+    sha256 = "e60793ab124e9054c1d5509698acbae507ebb2fab5364d964067bc9ae8b6b5e5";
   };
-
-  cargoPatches = [
-    ./libpijul.patch
-  ];
 
   nativeBuildInputs = [ pkgconfig ];
 
···
 
   doCheck = false;
 
-  cargoSha256 = "1419mlxa4p53hm5qzfd1yi2k0n1bcv8kaslls1nyx661vknhfamw";
+  cargoSha256 = "1r76azmka1d76ff0ddfhzr24b0ry496qrp13945i3vs0fgzk2sdz";
 
   meta = with stdenv.lib; {
     description = "A distributed version control system";

pkgs/applications/version-management/pijul/libpijul.patch

···
---- 2/pijul-0.10.0/Cargo.lock	1970-01-01 01:00:00.000000000 +0100
-+++ pijul-0.10.0/Cargo.lock	2018-10-28 10:09:48.557639255 +0000
-@@ -552,7 +552,7 @@
- 
- [[package]]
- name = "libpijul"
--version = "0.10.0"
-+version = "0.10.1"
- dependencies = [
-  "base64 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
-  "bincode 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
-@@ -577,9 +577,29 @@
- 
- [[package]]
- name = "libpijul"
--version = "0.10.0"
-+version = "0.10.2"
- source = "registry+https://github.com/rust-lang/crates.io-index"
--replace = "libpijul 0.10.0"
-+dependencies = [
-+ "base64 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
-+ "bincode 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
-+ "bitflags 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
-+ "bs58 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
-+ "byteorder 1.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
-+ "chrono 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
-+ "error-chain 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)",
-+ "flate2 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
-+ "hex 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
-+ "ignore 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
-+ "log 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
-+ "openssl 0.10.6 (registry+https://github.com/rust-lang/crates.io-index)",
-+ "rand 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
-+ "sanakirja 0.8.16 (registry+https://github.com/rust-lang/crates.io-index)",
-+ "serde 1.0.41 (registry+https://github.com/rust-lang/crates.io-index)",
-+ "serde_derive 1.0.41 (registry+https://github.com/rust-lang/crates.io-index)",
-+ "serde_json 1.0.15 (registry+https://github.com/rust-lang/crates.io-index)",
-+ "tempdir 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
-+ "thrussh-keys 0.9.5 (registry+https://github.com/rust-lang/crates.io-index)",
-+]
- 
- [[package]]
- name = "line"
-@@ -917,7 +937,7 @@
-  "hex 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
-  "ignore 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
-  "isatty 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
-- "libpijul 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
-+ "libpijul 0.10.2 (registry+https://github.com/rust-lang/crates.io-index)",
-  "line 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
-  "log 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
-  "pager 0.14.0 (registry+https://github.com/rust-lang/crates.io-index)",
-@@ -1796,7 +1816,7 @@
- "checksum lazycell 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)" = "a6f08839bc70ef4a3fe1d566d5350f519c5912ea86be0df1740a7d247c7fc0ef"
- "checksum libc 0.2.40 (registry+https://github.com/rust-lang/crates.io-index)" = "6fd41f331ac7c5b8ac259b8bf82c75c0fb2e469bbf37d2becbba9a6a2221965b"
- "checksum libflate 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)" = "1a429b86418868c7ea91ee50e9170683f47fd9d94f5375438ec86ec3adb74e8e"
--"checksum libpijul 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)" = "80fd579ba6762eac3f12c9624d5496edaba5a2f2e8785bcf8310372328e06ebe"
-+"checksum libpijul 0.10.2 (registry+https://github.com/rust-lang/crates.io-index)" = "cf6fc1aa0e9402f8283bdeb2507cfb6798d2f2f973da34c3f4b0c96a456b74cd"
- "checksum line 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "ecdd22a3856203276b7854e16213139428e82922530438f36356e5b361ea4a42"
- "checksum log 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)" = "e19e8d5c34a3e0e2223db8e060f9e8264aeeb5c5fc64a4ee9965c062211c024b"
- "checksum log 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)" = "89f010e843f2b1a31dbd316b3b8d443758bc634bed37aabade59c686d644e0a2"

pkgs/build-support/bintools-wrapper/default.nix

···
       /**/ if targetPlatform.isAarch64 then endianPrefix + "aarch64"
       else if targetPlatform.isAarch32     then endianPrefix + "arm"
       else if targetPlatform.isx86_64  then "x86-64"
-      else if targetPlatform.isi686    then "i386"
+      else if targetPlatform.isx86     then "i386"
       else if targetPlatform.isMips    then {
           "mips"     = "btsmipn32"; # n32 variant
           "mipsel"   = "ltsmipn32"; # n32 variant

pkgs/build-support/rust/default.nix

···
-{ stdenv, cacert, git, rust, cargo-vendor, python3 }:
-let
-  fetchcargo = import ./fetchcargo.nix {
-    inherit stdenv cacert git rust cargo-vendor python3;
-  };
-in
+{ stdenv, cacert, git, cargo, rustc, cargo-vendor, fetchcargo, python3 }:
+
 { name, cargoSha256 ? "unset"
 , src ? null
 , srcs ? null
···
 
   patchRegistryDeps = ./patch-registry-deps;
 
-  buildInputs = [ cacert git rust.cargo rust.rustc ] ++ buildInputs;
+  buildInputs = [ cacert git cargo rustc ] ++ buildInputs;
 
   patches = cargoPatches ++ patches;
 

pkgs/build-support/rust/fetchcargo.nix

···
-{ stdenv, cacert, git, rust, cargo-vendor, python3 }:
+{ stdenv, cacert, git, cargo, cargo-vendor, python3 }:
 let cargo-vendor-normalise = stdenv.mkDerivation {
   name = "cargo-vendor-normalise";
   src = ./cargo-vendor-normalise.py;
···
 { name ? "cargo-deps", src, srcs, patches, sourceRoot, sha256, cargoUpdateHook ? "" }:
 stdenv.mkDerivation {
   name = "${name}-vendor";
-  nativeBuildInputs = [ cacert cargo-vendor git cargo-vendor-normalise rust.cargo ];
+  nativeBuildInputs = [ cacert cargo-vendor git cargo-vendor-normalise cargo ];
   inherit src srcs patches sourceRoot;
 
   phases = "unpackPhase patchPhase installPhase";

pkgs/build-support/rust/make-rust-platform.nix

···
+{ callPackage }:
+{ rustc, cargo, ... }: {
+  rust = {
+    inherit rustc cargo;
+  };
+
+  buildRustPackage = callPackage ./default.nix {
+    inherit rustc cargo;
+
+    fetchcargo = callPackage ./fetchcargo.nix {
+      inherit cargo;
+    };
+  };
+
+  rustcSrc = callPackage ../../development/compilers/rust/rust-src.nix {
+    inherit rustc;
+  };
+}

pkgs/data/misc/hackage/default.nix

···
 { fetchurl }:
 
 fetchurl {
-  url = "https://github.com/commercialhaskell/all-cabal-hashes/archive/1fba236a8a8f685aaf55029d20ab24d7e4cbc5ba.tar.gz";
-  sha256 = "0yy6ass2c0vn81pcvb0ksc1qh3hlw2q97937vp73jawghgwsy9qv";
+  url = "https://github.com/commercialhaskell/all-cabal-hashes/archive/3487551670de487866a34bd466b33b5146087882.tar.gz";
+  sha256 = "10kag8qmlsnj3qwq0zxb6apd2z7jg17srvhsax5lgbwvlymbnckb";
 }

pkgs/development/compilers/gambit/bootstrap.nix

···
-{ stdenv, fetchurl, autoconf, ... }:
+{ stdenv, fetchurl, autoconf, git, ... }:
 
 stdenv.mkDerivation rec {
   name    = "gambit-bootstrap-${version}";
-  version = "4.8.9";
-  tarball_version = "v4_8_9";
+  version = "4.9.1";
+  tarball_version = "v4_9_1";
 
   src = fetchurl {
-    url    = "http://www.iro.umontreal.ca/~gambit/download/gambit/v4.8/source/gambit-${tarball_version}-devel.tgz";
-    sha256 = "b7f86c794711792ca556ce41f8bc7043dffc395c01bb6d8d119bc2f454f89fbf";
+    url    = "http://www.iro.umontreal.ca/~gambit/download/gambit/v4.9/source/gambit-${tarball_version}-devel.tgz";
+    sha256 = "10kzv568gimp9nzh5xw0h01vw50wi68z3awfp9ibqrpq2l0n7mw7";
   };
 
-  buildInputs = [ autoconf ];
+  buildInputs = [ autoconf git ];
 
   configurePhase = ''
     ./configure --prefix=$out

pkgs/development/compilers/gambit/build.nix

···
-{ stdenv, git, openssl, autoconf, pkgs, makeStaticLibraries, version, SRC }:
+{ stdenv, git, openssl, autoconf, pkgs, makeStaticLibraries, version, src }:
 
 stdenv.mkDerivation rec {
   name    = "gambit-${version}";
-  src     = SRC;
+  inherit src;
 
   bootstrap = import ./bootstrap.nix ( pkgs );
 

pkgs/development/compilers/gambit/default.nix

···
 { stdenv, callPackage, fetchurl }:
 
 callPackage ./build.nix {
-  version = "4.9.0";
-
-  SRC = fetchurl {
-    url = "http://www.iro.umontreal.ca/~gambit/download/gambit/v4.9/source/gambit-v4_9_0-devel.tgz";
-    sha256 = "0wyfpjs244zrbrdil9rfkdgcawvms84z0r77qwhwadghma4dqgjf";
+  version = "4.9.1";
+  src = fetchurl {
+    url = "http://www.iro.umontreal.ca/~gambit/download/gambit/v4.9/source/gambit-v4_9_1-devel.tgz";
+    sha256 = "10kzv568gimp9nzh5xw0h01vw50wi68z3awfp9ibqrpq2l0n7mw7";
   };
   inherit stdenv;
 }

pkgs/development/compilers/gambit/unstable.nix

···
-{ stdenv, callPackage, fetchgit }:
+{ stdenv, callPackage, fetchFromGitHub }:
 
 callPackage ./build.nix {
-  version = "unstable-2018-09-03";
-# git-version = "4.9.0";
-  SRC = fetchgit {
-    url = "https://github.com/feeley/gambit.git";
-    rev = "7cdc7e7b9194b2c088c0667efaf7686a4ffd0d8a";
-    sha256 = "06mmi8jkinihfirz4gjfw2lhxhskiqf3d47sihzx10r60asyqcxg";
+  version = "unstable-2018-11-19";
+# git-version = "4.9.1-8-g61c6cb50";
+  src = fetchFromGitHub {
+    owner = "feeley";
+    repo = "gambit";
+    rev = "61c6cb500f4756be1e52095d5ab4501752525a70";
+    sha256 = "1knpb40y1g09c6yqd2fsxm3bk56bl5xrrwfsd7nqa497x6ngm5pn";
   };
   inherit stdenv;
 }

pkgs/development/compilers/gerbil/build.nix

···
 { stdenv, makeStaticLibraries,
   coreutils, rsync, bash,
   openssl, zlib, sqlite, libxml2, libyaml, mysql, lmdb, leveldb, postgresql,
-  version, git-version, GAMBIT, SRC }:
+  version, git-version, gambit, src }:
 
 # TODO: distinct packages for gerbil-release and gerbil-devel
 # TODO: make static compilation work
 
 stdenv.mkDerivation rec {
   name    = "gerbil-${version}";
-  src     = SRC;
+  inherit src;
 
   # Use makeStaticLibraries to enable creation of statically linked binaries
   buildInputs_libraries = [ openssl zlib sqlite libxml2 libyaml mysql.connector-c lmdb leveldb postgresql ];
   buildInputs_staticLibraries = map makeStaticLibraries buildInputs_libraries;
 
-  buildInputs = [ GAMBIT coreutils rsync bash ]
+  buildInputs = [ gambit rsync bash ]
     ++ buildInputs_libraries ++ buildInputs_staticLibraries;
 
   NIX_CFLAGS_COMPILE = [ "-I${mysql.connector-c}/include/mysql" "-L${mysql.connector-c}/lib/mysql" ];
···
 export GERBIL_HOME=$out
 case "\$1" in -:*) GSIOPTIONS=\$1 ; shift ;; esac
 if [[ \$# = 0 ]] ; then
-  exec ${GAMBIT}/bin/gsi \$GSIOPTIONS \$GERBIL_HOME/lib/gxi-init \$GERBIL_HOME/lib/gxi-interactive - ;
+  exec ${gambit}/bin/gsi \$GSIOPTIONS \$GERBIL_HOME/lib/gxi-init \$GERBIL_HOME/lib/gxi-interactive - ;
 else
-  exec ${GAMBIT}/bin/gsi \$GSIOPTIONS \$GERBIL_HOME/lib/gxi-init "\$@"
+  exec ${gambit}/bin/gsi \$GSIOPTIONS \$GERBIL_HOME/lib/gxi-init "\$@"
 fi
 EOF
     runHook postInstall

pkgs/development/compilers/gerbil/default.nix

···
-{ stdenv, callPackage, fetchurl, gambit }:
+{ stdenv, callPackage, fetchFromGitHub, gambit }:
 
-callPackage ./build.nix {
-  version = "0.13";
-  git-version = "0.13";
-  GAMBIT = gambit;
-  SRC = fetchurl {
-    url = "https://github.com/vyzo/gerbil/archive/v0.13.tar.gz";
-    sha256 = "1qs0vdq2lgxlpw20s8jzw2adx1xk9wb3w2m4a8vp6bb8hagmfr5l";
+callPackage ./build.nix rec {
+  version = "0.14";
+  git-version = "0.14";
+  inherit gambit;
+  src = fetchFromGitHub {
+    owner = "vyzo";
+    repo = "gerbil";
+    rev = "v${version}";
+    sha256 = "0n078lkf8m391kr99ipb1v2dpi5vkikz9nj0p7kfjg43868my3v7";
   };
   inherit stdenv;
 }

pkgs/development/compilers/gerbil/unstable.nix

···
-{ stdenv, callPackage, fetchgit, gambit-unstable }:
+{ stdenv, callPackage, fetchFromGitHub, gambit-unstable }:
 
 callPackage ./build.nix {
-  version = "unstable-2018-09-06";
-  git-version = "0.14-DEV";
-  GAMBIT = gambit-unstable;
-  SRC = fetchgit {
-    url = "https://github.com/vyzo/gerbil.git";
-    rev = "184cb635c82517d5d75d7966dcdf1d25ad863dac";
-    sha256 = "1ljzbpc36i9zpzfwra5hpfbgzj1dyzzp50h5jf976n8qr9x4l7an";
+  version = "unstable-2018-11-19";
+  git-version = "0.15-DEV-2-g7d09a4ce";
+  gambit = gambit-unstable;
+  src = fetchFromGitHub {
+    owner = "vyzo";
+    repo = "gerbil";
+    rev = "7d09a4cebe03d755a1791e77279e156a74e07685";
+    sha256 = "1mqi9xcjk59sqbh1fx65a4fa4mqm35py4xqxq6086bcyhkm1nzwa";
   };
   inherit stdenv;
 }

pkgs/development/compilers/ghc/8.2.1-binary.nix pkgs/development/compilers/ghc/8.2.2-binary.nix

···
 in
 
 stdenv.mkDerivation rec {
-  version = "8.2.1";
+  version = "8.2.2";
 
   name = "ghc-${version}-binary";
 
   src = fetchurl ({
     "i686-linux" = {
       url = "http://haskell.org/ghc/dist/${version}/ghc-${version}-i386-deb8-linux.tar.xz";
-      sha256 = "d86f9c157dd4161a8acb14062c131c8985a4f65fc856603c373502be1d50c95e";
+      sha256 = "08w2ik55dp3n95qikmrflc91lsiq01xp53ki3jlhnbj8fqnxfrwy";
     };
     "x86_64-linux" = {
       url = "http://haskell.org/ghc/dist/${version}/ghc-${version}-x86_64-deb8-linux.tar.xz";
-      sha256 = "543b81bf610240bd0398111d6c6607a9094dc2d159b564057d46c8a3d1aaa130";
+      sha256 = "0ahv26304pqi3dm7i78si4pxwvg5f5dc2jwsfgvcrhcx5g30bqj8";
     };
     "armv7l-linux" = {
       url = "http://haskell.org/ghc/dist/${version}/ghc-${version}-armv7-deb8-linux.tar.xz";
-      sha256 = "0f0e5e1d4fad3fa1a87ca1fe0d19242f4a94d158b7b8a08f99efefd98b51b019";
+      sha256 = "1jmv8qmnh5bn324fivbwdcaj55kvw7cb2zq9pafmlmv3qwwx7s46";
     };
     "aarch64-linux" = {
       url = "http://haskell.org/ghc/dist/${version}/ghc-${version}-aarch64-deb8-linux.tar.xz";
-      sha256 = "61dab9c95ef9f9af8bce7338863fda3e42945eb46194b12d922b6d0dc245d0c2";
+      sha256 = "1k2amylcp1ad67c75h1pqf7czf9m0zj1i7hdc45ghjklnfq9hrk7";
     };
     "x86_64-darwin" = {
       url = "http://haskell.org/ghc/dist/${version}/ghc-${version}-x86_64-apple-darwin.tar.xz";
-      sha256 = "900c802025fb630060dbd30f9738e5d107a4ca5a50d5c1262cd3e69fe4467188";
+      sha256 = "09swx71gh5habzbx55shz2xykgr96xkcy09nzinnm4z0yxicy3zr";
     };
   }.${stdenv.hostPlatform.system}
     or (throw "cannot bootstrap GHC on this platform"));

pkgs/development/compilers/go/1.10.nix

···
   disallowedReferences = [ go_bootstrap ];
 
   meta = with stdenv.lib; {
-    branch = "1.9";
+    branch = "1.10";
     homepage = http://golang.org/;
     description = "The Go Programming language";
     license = licenses.bsd3;

pkgs/development/compilers/go/1.11.nix

···
   disallowedReferences = [ go_bootstrap ];
 
   meta = with stdenv.lib; {
-    branch = "1.9";
+    branch = "1.11";
     homepage = http://golang.org/;
     description = "The Go Programming language";
     license = licenses.bsd3;

pkgs/development/guile-modules/guile-sdl2/default.nix

···
 let
   name = "${pname}-${version}";
   pname = "guile-sdl2";
-  version = "0.2.0";
+  version = "0.3.1";
 in stdenv.mkDerivation {
   inherit name;
 
   src = fetchurl {
     url = "https://files.dthompson.us/${pname}/${name}.tar.gz";
-    sha256 = "0yq9lsl17cdvj77padvpk3jcw2g6g0pck9jrchc7n2767rrc012b";
+    sha256 = "0bw7x2lx90k4banc5k7yfkn3as93y25gr1xdr225ll7lmij21k64";
   };
 
+  nativeBuildInputs = [ libtool pkgconfig ];
   buildInputs = [
-    guile libtool pkgconfig
-    SDL2 SDL2_image SDL2_ttf SDL2_mixer
+    guile SDL2 SDL2_image SDL2_ttf SDL2_mixer
   ];
 
   configureFlags = [

pkgs/development/haskell-modules/configuration-common.nix

···
   # We cannot build this package w/o the C library from <http://www.phash.org/>.
   phash = markBroken super.phash;
 
-  # https://github.com/deech/fltkhs/issues/16
-  # linking fails because the build doesn't pull in the libGLU_combined libraries
-  fltkhs = markBroken super.fltkhs;
-  fltkhs-fluid-examples = dontDistribute super.fltkhs-fluid-examples;
-
   # We get lots of strange compiler errors during the test suite run.
   jsaddle = dontCheck super.jsaddle;
 

pkgs/development/haskell-modules/configuration-ghc-8.6.x.nix

···
   hspec-core = self.hspec-core_2_6_0;
   hspec-discover = self.hspec-discover_2_6_0;
   hspec-megaparsec = doJailbreak super.hspec-megaparsec;  # newer versions need megaparsec 7.x
-  hspec-meta = self.hspec-meta_2_5_6;
+  hspec-meta = self.hspec-meta_2_6_0;
   JuicyPixels = self.JuicyPixels_3_3_2;
   lens = self.lens_4_17;
   megaparsec = dontCheck (doJailbreak super.megaparsec);

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

···
     ({ mkDerivation, base }:
      mkDerivation {
        pname = "RtMidi";
-       version = "0.1.0.0";
-       sha256 = "087p4smmbi56y962lchgs2a6q78jab58bl6c5sxir7973hplyly6";
+       version = "0.1.1.0";
+       sha256 = "09vs2y6zry4xak0gc6pc6xqinr9sv9z53hdiydxpn6ixam9s0g5r";
        libraryHaskellDepends = [ base ];
        license = stdenv.lib.licenses.mit;
        hydraPlatforms = stdenv.lib.platforms.none;
···
        testHaskellDepends = [ base hspec QuickCheck ];
        description = "Multi-precision floats via MPFR";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "aern2-mp_0_1_3_1" = callPackage
+    ({ mkDerivation, base, convertible, hspec, integer-logarithms, lens
+     , mixed-types-num, QuickCheck, regex-tdfa, rounded
+     , template-haskell
+     }:
+     mkDerivation {
+       pname = "aern2-mp";
+       version = "0.1.3.1";
+       sha256 = "1gyicxsdqzdbhs9bss5cfjqx859iksr7z1ilsfm9077jdf2032vm";
+       libraryHaskellDepends = [
+         base convertible hspec integer-logarithms lens mixed-types-num
+         QuickCheck regex-tdfa rounded template-haskell
+       ];
+       testHaskellDepends = [ base hspec QuickCheck ];
+       description = "Multi-precision ball (interval) arithmetic";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "aern2-real" = callPackage
···
      }:
      mkDerivation {
        pname = "arbor-monad-counter";
-       version = "2.0.0";
-       sha256 = "1pzgqxrsfaq9l6400ykv8gz34z90r0lwq93pzadsq5qpkhk55053";
+       version = "2.0.1";
+       sha256 = "0fkf71ml6qfsxjx1p7gqf41q8x55hn8qsbb7nmyai0k0vz0s2yqq";
        libraryHaskellDepends = [
          base containers generic-lens lens mtl resourcet stm transformers
        ];
···
      }:
      mkDerivation {
        pname = "arbor-postgres";
-       version = "0.0.2";
-       sha256 = "04fly3bwzkv30j79rzm5mk5af3j28z6grnixl2ll3nnqmbwkwr2n";
+       version = "0.0.3";
+       sha256 = "18rqy2zyaf5cawn8dkn3xmjh19zzqgwj6mkk415x5a4p53dya46b";
        libraryHaskellDepends = [
          base bytestring generic-lens lens network-uri optparse-applicative
          postgresql-simple text
···
      }:
      mkDerivation {
        pname = "asif";
-       version = "3.1.0";
-       sha256 = "0z9i40xz7hnhqnxv79saj9wsigi25bxkn0v4p5fhvfqj3r06ms2l";
+       version = "3.2.0";
+       sha256 = "0ryg35rl7i89r28l0hpchgmrgmhxwgzxz7jhnwhqfwk5mql08hq0";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "base-unicode-symbols_0_2_3" = callPackage
+    ({ mkDerivation, base }:
+     mkDerivation {
+       pname = "base-unicode-symbols";
+       version = "0.2.3";
+       sha256 = "1ia6li7qjg1zkak4gf6mnbshw45mq9bfjr0jch58ds0lscmvwyzf";
+       libraryHaskellDepends = [ base ];
+       description = "Unicode alternatives for common functions and operators";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "base16-bytestring" = callPackage
     ({ mkDerivation, base, bytestring, ghc-prim }:
      mkDerivation {
···
        pname = "bhoogle";
        version = "0.1.3.5";
        sha256 = "1gig9w1k1w2kw6y3wx6ckmc7kamwwzzq7mbaxil0rmb5ms0p1rf9";
-       revision = "1";
-       editedCabalFile = "006nqwl03lrs7nsly7l3kl9wfwabflkkxy4g34sbkik88ihipw56";
+       revision = "2";
+       editedCabalFile = "0jwfw2xa55ysfxyzp5n2pf2vq753iagpmvg9xnj69nv6ly9whfp7";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "casa-abbreviations-and-acronyms";
-       version = "0.0.6";
-       sha256 = "0dsw097629a1jkl36s4bip7pl60i3mw7v9d70p5jmajxv9wn3zjy";
+       version = "0.0.7";
+       sha256 = "16xdkbgym1jjqnmx10h3yfq2zw3mzpf7jskssf4nzm6dsvj1msp5";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }) {};
 
   "chiphunk" = callPackage
-    ({ mkDerivation, base, safe-exceptions, StateVar, vector-space }:
+    ({ mkDerivation, base, c2hs, safe-exceptions, StateVar
+     , vector-space
+     }:
      mkDerivation {
        pname = "chiphunk";
-       version = "0.1.0.2";
-       sha256 = "1xwqmkf6b32zpb18fx9a87s1kybif18123k4i7qvnagizv97jm4q";
+       version = "0.1.0.3";
+       sha256 = "0a39x0v5pswaz4b9nbq1cmi172qglcfk54f5w7sb0ldx88qqi9d3";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          base safe-exceptions StateVar vector-space
        ];
+       libraryToolDepends = [ c2hs ];
        description = "Haskell bindings for Chipmunk2D physics engine";
        license = stdenv.lib.licenses.bsd3;
      }) {};
···
        license = stdenv.lib.licenses.mpl20;
      }) {};
 
+  "co-log-sys" = callPackage
+    ({ mkDerivation, aeson, base-noprelude, co-log-core, fmt
+     , loot-prelude, microlens, monad-control, mtl, network, universum
+     , unix
+     }:
+     mkDerivation {
+       pname = "co-log-sys";
+       version = "0.1.0.0";
+       sha256 = "02lh14jhl5qyjlacbp62a6193fqc6p3nk30pksnw5zz8dsyj5iz2";
+       libraryHaskellDepends = [
+         aeson base-noprelude co-log-core fmt loot-prelude microlens
+         monad-control mtl network universum unix
+       ];
+       testHaskellDepends = [
+         aeson base-noprelude co-log-core fmt loot-prelude microlens
+         monad-control mtl network universum unix
+       ];
+       description = "Syslog implementation on top of 'co-log-core'";
+       license = stdenv.lib.licenses.mpl20;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {loot-prelude = null;};
+
   "coalpit" = callPackage
     ({ mkDerivation, base, generic-random, megaparsec, network-uri
      , scientific, tasty, tasty-quickcheck, tasty-travis, time
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "commutative_0_0_2" = callPackage
+    ({ mkDerivation, base, QuickCheck, quickcheck-instances, random
+     , semigroups, tasty, tasty-hunit, tasty-quickcheck, vector
+     }:
+     mkDerivation {
+       pname = "commutative";
+       version = "0.0.2";
+       sha256 = "0scrc0bwa3ggvhmhmj0pvi7q7sbm495nc8m30jjjcp5wbd26mg6c";
+       libraryHaskellDepends = [ base random semigroups vector ];
+       testHaskellDepends = [
+         base QuickCheck quickcheck-instances random semigroups tasty
+         tasty-hunit tasty-quickcheck vector
+       ];
+       description = "Commutative binary operations";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "comonad" = callPackage
     ({ mkDerivation, base, Cabal, cabal-doctest, containers
      , contravariant, distributive, doctest, semigroups, tagged
···
        license = stdenv.lib.licenses.bsd2;
      }) {};
 
+  "concurrent-output_1_10_9" = callPackage
+    ({ mkDerivation, ansi-terminal, async, base, directory, exceptions
+     , process, stm, terminal-size, text, transformers, unix
+     }:
+     mkDerivation {
+       pname = "concurrent-output";
+       version = "1.10.9";
+       sha256 = "0mwf155w89nbbkjln7hhbn8k3f8p0ylcvgrg31cm7ijpx4499i4c";
+       libraryHaskellDepends = [
+         ansi-terminal async base directory exceptions process stm
+         terminal-size text transformers unix
+       ];
+       description = "Ungarble output from several threads or commands";
+       license = stdenv.lib.licenses.bsd2;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "concurrent-rpc" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "egison";
-       version = "3.7.13";
-       sha256 = "1kxlg7znyv4iaygm6gk50zw4vcijfmc16vl5bwif179v3r8nrpxn";
+       version = "3.7.14";
+       sha256 = "0iilizs6nj901fmzfam9s0s2phz91m2292wggqvzj8p6260589iq";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        pname = "ekg";
        version = "0.4.0.15";
        sha256 = "1k3d5kiqm034qs04k0pcisf4zbdmx2fcgl9a6c1lzzjw96zf6aj8";
-       revision = "4";
-       editedCabalFile = "17b68p16hsh79jaya1jfncml5cjf8y1jbr8827r42acnf9jk4s23";
+       revision = "5";
+       editedCabalFile = "0jwzwqr4giinq6wvl46399454nm9vc5g6mc2k2mx4wjdcl07qbgm";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          aeson base bytestring ekg-core ekg-json filepath network snap-core
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "ekg-core_0_1_1_6" = callPackage
+    ({ mkDerivation, base, containers, ghc-prim, text
+     , unordered-containers
+     }:
+     mkDerivation {
+       pname = "ekg-core";
+       version = "0.1.1.6";
+       sha256 = "0hjprlx99k7mgs2zn06yckir71dvz90xs24g2r990r97mmwxva36";
+       libraryHaskellDepends = [
+         base containers ghc-prim text unordered-containers
+       ];
+       benchmarkHaskellDepends = [ base ];
+       description = "Tracking of system metrics";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "ekg-elastic" = callPackage
     ({ mkDerivation, aeson, base, bytestring, ekg-core, hostname
      , http-client, lens, text, time, unordered-containers, wreq
···
        pname = "ekg-json";
        version = "0.1.0.6";
        sha256 = "0iyx0ix4dcyhh9xg4ia1lm7x2q0iffswnr33khfg9fr81am80shy";
-       revision = "3";
-       editedCabalFile = "0d029nmwpln8iqqj1l5pz41l4gpbgk6n9gmlwnhnq2cm7ih6gzad";
+       revision = "4";
+       editedCabalFile = "16sn4nbqm0rxkf0swi6r2jn6z9x92qmcg9xlx258d98kqb5fkwjg";
        libraryHaskellDepends = [
          aeson base ekg-core text unordered-containers
        ];
···
        pname = "ekg-statsd";
        version = "0.2.4.0";
        sha256 = "1nvsiblha1fzykvfaq1s0fyvfmhm32wvxdsfkn9pqd6dl5ivyx2y";
-       revision = "1";
-       editedCabalFile = "1iayg5ac94rgdz7shvvz7ff4saffww8dc6fy82hi0cpyk7kr2xy9";
+       revision = "2";
+       editedCabalFile = "1l0lh77qy4kbybkys1d4gg563fc593w27wpf4k1cg9j6ix6y604x";
        libraryHaskellDepends = [
          base bytestring ekg-core network text time unordered-containers
        ];
···
      }:
      mkDerivation {
        pname = "extensible-effects-concurrent";
-       version = "0.14.0";
-       sha256 = "1vs53jbpfqx6hyri7abhg6k6lhhyjlf3lyn1lcij28y2sfi6zs1j";
+       version = "0.14.1";
+       sha256 = "03xlzxijs79l9q548yggfazr4rds4xg9hn2nmijp3q8wv5rn1srm";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "fast-builder";
-       version = "0.0.1.0";
-       sha256 = "09s0jyiv1ch8cbgwfaxn5mmn9w7ik661h2g6d5znxr0nsi0bp2n1";
+       version = "0.1.0.0";
+       sha256 = "1sc5hgiagjcsblbzlymd9z140ybmq03l6xykksjdx0xkwj4sqrp2";
        libraryHaskellDepends = [ base bytestring ghc-prim ];
        testHaskellDepends = [ base bytestring process QuickCheck stm ];
        benchmarkHaskellDepends = [
···
 
   "fltkhs" = callPackage
     ({ mkDerivation, base, bytestring, c2hs, Cabal, directory, filepath
-     , mtl, parsec, pkg-config, text, vector
+     , fltk14, libGLU_combined, mtl, OpenGLRaw, parsec, pkgconfig, text
+     , vector
      }:
      mkDerivation {
        pname = "fltkhs";
        version = "0.6.0.0";
        sha256 = "1cbyp8rq9yzx6jrw68dbprkdyd8pkdqbxx08wajyg7bfks6j39cb";
+       configureFlags = [ "-fopengl" ];
        isLibrary = true;
        isExecutable = true;
        setupHaskellDepends = [ base Cabal directory filepath ];
        libraryHaskellDepends = [ base bytestring text vector ];
-       libraryToolDepends = [ c2hs pkg-config ];
-       executableHaskellDepends = [ base directory filepath mtl parsec ];
+       librarySystemDepends = [ fltk14 ];
+       libraryPkgconfigDepends = [ libGLU_combined ];
+       libraryToolDepends = [ c2hs pkgconfig ];
+       executableHaskellDepends = [
+         base directory filepath mtl OpenGLRaw parsec text
+       ];
        description = "FLTK bindings";
        license = stdenv.lib.licenses.mit;
-     }) {pkg-config = null;};
+     }) {inherit (pkgs) fltk14; inherit (pkgs) libGLU_combined; 
+         inherit (pkgs) pkgconfig;};
 
   "fltkhs-demos" = callPackage
     ({ mkDerivation, base, bytestring, directory, fltkhs, process, stm
···
        pname = "focuslist";
        version = "0.1.0.0";
        sha256 = "1przphis37yh06q2scqh2njcrvgynh0p9km52f4a5yvmnxvaqs8n";
+       revision = "1";
+       editedCabalFile = "1935ng4pxqhakz78fgwyliwmvdgnj9pq5344421jqa5krclywab5";
        isLibrary = true;
        isExecutable = true;
        setupHaskellDepends = [ base Cabal cabal-doctest ];
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "glabrous_0_4_0" = callPackage
+  "glabrous_1_0_0" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, attoparsec, base, bytestring
      , cereal, cereal-text, directory, either, hspec, text
      , unordered-containers
      }:
      mkDerivation {
        pname = "glabrous";
-       version = "0.4.0";
-       sha256 = "0qja5mdnbgrsdiwqjfwrzzynbybwg5yksvnwgazak0wv2p86i5yh";
+       version = "1.0.0";
+       sha256 = "00q07675lrsniwrzb85bz2b5n8llbhyp0zxkscm9yr8mlirasr3k";
        libraryHaskellDepends = [
          aeson aeson-pretty attoparsec base bytestring cereal cereal-text
          either text unordered-containers
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "haskell-src-exts-util_0_2_4" = callPackage
+    ({ mkDerivation, base, containers, data-default, haskell-src-exts
+     , semigroups, transformers, uniplate
+     }:
+     mkDerivation {
+       pname = "haskell-src-exts-util";
+       version = "0.2.4";
+       sha256 = "1xbf28aisqizy3a0sy42p3rwib2s7jaqi6dcr6lp4b1j54xazf5y";
+       libraryHaskellDepends = [
+         base containers data-default haskell-src-exts semigroups
+         transformers uniplate
+       ];
+       description = "Helper functions for working with haskell-src-exts trees";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "haskell-src-meta" = callPackage
     ({ mkDerivation, base, haskell-src-exts, HUnit, pretty, syb
      , template-haskell, test-framework, test-framework-hunit
···
      }:
      mkDerivation {
        pname = "haskoin-store";
-       version = "0.6.5";
-       sha256 = "0hh1h02sb2v8d0g70cx57nrd9s20q2grjyf2rzsqcs8ihwi5z1wf";
+       version = "0.6.9";
+       sha256 = "1353cr6bd814xa1d2jqqnh2h5jmlkdsfg1a4cmxwyl1wvprjx54i";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
 
   "haskus-binary" = callPackage
     ({ mkDerivation, base, bytestring, cereal, criterion, haskus-utils
-     , mtl, QuickCheck, tasty, tasty-quickcheck
+     , haskus-utils-data, haskus-utils-types, mtl, QuickCheck, tasty
+     , tasty-quickcheck
      }:
      mkDerivation {
        pname = "haskus-binary";
-       version = "1.0";
-       sha256 = "1gw08zx7mqhi6n0wx6s6n4fvw5ambbdxnahr3r3p22yfqnqcp4y2";
+       version = "1.1";
+       sha256 = "1kva6wsxybd9hj9ml2ykzcfcsh83fcwqdv3gyp702rnk53q9r8r5";
        libraryHaskellDepends = [
-         base bytestring cereal haskus-utils mtl
+         base bytestring cereal haskus-utils haskus-utils-data
+         haskus-utils-types mtl
        ];
        testHaskellDepends = [
          base bytestring haskus-utils QuickCheck tasty tasty-quickcheck
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "hcobs" = callPackage
+    ({ mkDerivation, base, base64-bytestring, bytestring, containers
+     , criterion, deepseq, ghc-prim, hedgehog, mmorph, mtl, reflection
+     , weigh
+     }:
+     mkDerivation {
+       pname = "hcobs";
+       version = "0.1.0.1";
+       sha256 = "103x2486yb0p9bxwhd8ywhr59pgnkgyr4z70bsv6xcs54g0zqdy7";
+       libraryHaskellDepends = [
+         base bytestring containers ghc-prim reflection
+       ];
+       testHaskellDepends = [
+         base base64-bytestring bytestring deepseq ghc-prim hedgehog mmorph
+         mtl reflection weigh
+       ];
+       benchmarkHaskellDepends = [
+         base base64-bytestring bytestring criterion ghc-prim reflection
+       ];
+       description = "An implementation of the Consistent Overhead Byte Stuffing algorithm";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "hcom" = callPackage
     ({ mkDerivation }:
      mkDerivation {
···
        benchmarkHaskellDepends = [ base mtl time ];
        description = "Client library for the Redis datastore: supports full command set, pipelining";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "hedis_0_10_6" = callPackage
+    ({ mkDerivation, async, base, bytestring, bytestring-lexing
+     , deepseq, doctest, errors, HTTP, HUnit, mtl, network, network-uri
+     , resource-pool, scanner, slave-thread, stm, test-framework
+     , test-framework-hunit, text, time, tls, unordered-containers
+     , vector
+     }:
+     mkDerivation {
+       pname = "hedis";
+       version = "0.10.6";
+       sha256 = "0s5snr3qbr2yd1ij6ifsrjaabx24ppmckz7ygdsr6c2fd99hijai";
+       libraryHaskellDepends = [
+         async base bytestring bytestring-lexing deepseq errors HTTP mtl
+         network network-uri resource-pool scanner stm text time tls
+         unordered-containers vector
+       ];
+       testHaskellDepends = [
+         async base bytestring doctest HUnit mtl slave-thread stm
+         test-framework test-framework-hunit text time
+       ];
+       benchmarkHaskellDepends = [ base mtl time ];
+       description = "Client library for the Redis datastore: supports full command set, pipelining";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "hedis-config" = callPackage
···
        pname = "hledger-iadd";
        version = "1.3.6";
        sha256 = "04gy5pvbcgkr3jg1a2dav3kcd7ih46knn0d39l8670bmwhx3y5br";
-       revision = "1";
-       editedCabalFile = "067mrhg3m77ygv6cph5cxxcyd23acg9mq2fhpkl7714blc58z97v";
+       revision = "3";
+       editedCabalFile = "0knyxgscbhddizdnljjs2ih73kf2s8acyzhrvhwdmw4c14560x45";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "homplexity";
-       version = "0.4.4.1";
-       sha256 = "08y95wjs7kakhzqb4z5rgs43mgdvr0qjl6gg53kwf0k112fqi5nd";
+       version = "0.4.4.3";
+       sha256 = "1gb4bkzkkka5kzq9zy085pivswxxp2bbi271dgjm6harlrlmnkk2";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          base containers cpphs deepseq directory filepath haskell-src-exts
          hflags template-haskell uniplate
        ];
+       libraryToolDepends = [ happy ];
        executableHaskellDepends = [
          base containers cpphs deepseq directory filepath haskell-src-exts
          hflags template-haskell uniplate
        ];
-       executableToolDepends = [ happy ];
        testHaskellDepends = [ base haskell-src-exts uniplate ];
        description = "Haskell code quality tool";
        license = stdenv.lib.licenses.bsd3;
···
        pname = "hpqtypes";
        version = "1.6.0.0";
        sha256 = "1aydpbkp5if7416dvswiygn7vfhgg7nza9p011gld18pr9mpsf5i";
-       revision = "1";
-       editedCabalFile = "0jmvhnmr9d7wcknx7prbc1dc6i08afkqbgnigil6y4mvv1m0cw6p";
+       revision = "4";
+       editedCabalFile = "0ap170l390j0iwxlrrqarnxqp2bbpfv0xjkxnwdri0ksw7p7h7i2";
        setupHaskellDepends = [ base Cabal directory filepath ];
        libraryHaskellDepends = [
          aeson async base bytestring containers data-default-class
···
      }:
      mkDerivation {
        pname = "hpqtypes-extras";
-       version = "1.6.2.0";
-       sha256 = "095kxfk12bzl7gl44fa7xmwfnx63707s1jz861hqjmi9dv3mm8kp";
-       revision = "1";
-       editedCabalFile = "0ifzjs8vvnb9viksgakvjz69yppppgx8iqz2pqvb2dnwjwk4hamd";
+       version = "1.6.3.0";
+       sha256 = "13360sw1nmcgvhmj2inh8v4yccrfbs5b83jfsx1q0s6cfx6z7s37";
        libraryHaskellDepends = [
          base base16-bytestring bytestring containers cryptohash
          data-default exceptions fields-json hpqtypes lifted-base log-base
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "hquantlib_0_0_5_0" = callPackage
+    ({ mkDerivation, base, containers, hmatrix, hmatrix-gsl
+     , hmatrix-special, hquantlib-time, HUnit, mersenne-random-pure64
+     , parallel, QuickCheck, random, statistics, test-framework
+     , test-framework-hunit, test-framework-quickcheck2, time, vector
+     , vector-algorithms
+     }:
+     mkDerivation {
+       pname = "hquantlib";
+       version = "0.0.5.0";
+       sha256 = "1zi31y89kdbid3xjvpsd2iqwvn8a7d2i5518maigkmhp5v1lg0w6";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base containers hmatrix hmatrix-gsl hmatrix-special hquantlib-time
+         mersenne-random-pure64 parallel random statistics time vector
+         vector-algorithms
+       ];
+       executableHaskellDepends = [
+         base containers mersenne-random-pure64 parallel time
+       ];
+       testHaskellDepends = [
+         base HUnit QuickCheck test-framework test-framework-hunit
+         test-framework-quickcheck2
+       ];
+       description = "HQuantLib is a port of essencial parts of QuantLib to Haskell";
+       license = "LGPL";
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
+  "hquantlib-time" = callPackage
+    ({ mkDerivation, base, time }:
+     mkDerivation {
+       pname = "hquantlib-time";
+       version = "0.0.4.1";
+       sha256 = "0g2j7m14ic40lhcnbvfjya3qh7ngx658qlmrr0dzr5r1ywcyv75c";
+       libraryHaskellDepends = [ base time ];
+       description = "HQuantLib Time is a business calendar functions extracted from HQuantLib";
+       license = "LGPL";
+     }) {};
+
   "hquery" = callPackage
     ({ mkDerivation, base, bytestring, containers, filepath, HUnit
      , parsec, test-framework, test-framework-hunit, text, xmlhtml
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
-  "hspec-meta_2_5_6" = callPackage
+  "hspec-meta_2_6_0" = callPackage
     ({ mkDerivation, ansi-terminal, array, base, call-stack, clock
      , deepseq, directory, filepath, hspec-expectations, HUnit
      , QuickCheck, quickcheck-io, random, setenv, stm, time
···
      }:
      mkDerivation {
        pname = "hspec-meta";
-       version = "2.5.6";
-       sha256 = "196dyacvh7liq49ccwd5q0dw6n74igrvhk35zm95i3y8m44ky3a4";
-       revision = "1";
-       editedCabalFile = "0c7dq1vvk09fj6nljwwshgpkszg725hrpgnq9l2aka230sig9vz4";
+       version = "2.6.0";
+       sha256 = "1n1a4633wfivylglji8920f67mx7qz8j4q58n8p7dxk6yg4h3mz6";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "http-client_0_5_14" = callPackage
+    ({ mkDerivation, array, async, base, blaze-builder, bytestring
+     , case-insensitive, containers, cookie, deepseq, directory
+     , exceptions, filepath, ghc-prim, hspec, http-types, memory
+     , mime-types, monad-control, network, network-uri, random, stm
+     , streaming-commons, text, time, transformers, zlib
+     }:
+     mkDerivation {
+       pname = "http-client";
+       version = "0.5.14";
+       sha256 = "0irnvrxlsr9f7ybvzbpv24zbq3lhxjzh6bavjnl527020jbl0l4f";
+       libraryHaskellDepends = [
+         array base blaze-builder bytestring case-insensitive containers
+         cookie deepseq exceptions filepath ghc-prim http-types memory
+         mime-types network network-uri random stm streaming-commons text
+         time transformers
+       ];
+       testHaskellDepends = [
+         async base blaze-builder bytestring case-insensitive containers
+         deepseq directory hspec http-types monad-control network
+         network-uri streaming-commons text time transformers zlib
+       ];
+       doCheck = false;
+       description = "An HTTP client engine";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "http-client-auth" = callPackage
     ({ mkDerivation, base, base64-string, blaze-builder, bytestring
      , case-insensitive, conduit, crypto-conduit, http-client
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "hw-bits_0_7_0_4" = callPackage
+    ({ mkDerivation, base, bytestring, criterion, hedgehog, hspec
+     , hw-hspec-hedgehog, hw-int, hw-prim, hw-string-parse, QuickCheck
+     , safe, vector
+     }:
+     mkDerivation {
+       pname = "hw-bits";
+       version = "0.7.0.4";
+       sha256 = "1si3y3wnp1ing32b6bbhxzy5ai971ipkd28qw8b15a3vqwlkk5gw";
+       libraryHaskellDepends = [
+         base bytestring hw-int hw-prim hw-string-parse safe vector
+       ];
+       testHaskellDepends = [
+         base bytestring hedgehog hspec hw-hspec-hedgehog hw-prim QuickCheck
+         vector
+       ];
+       benchmarkHaskellDepends = [ base criterion hw-prim vector ];
+       description = "Bit manipulation";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "hw-conduit" = callPackage
     ({ mkDerivation, array, base, bytestring, conduit
      , conduit-combinators, criterion, hspec, mmap, time, transformers
···
        description = "Unbelievably fast streaming DSV file parser";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
+  "hw-dump" = callPackage
+    ({ mkDerivation, base, bits-extra, bytestring, criterion, hedgehog
+     , hspec, hw-bits, hw-hspec-hedgehog, hw-prim, lens
+     , optparse-applicative, QuickCheck, safe, vector
+     }:
+     mkDerivation {
+       pname = "hw-dump";
+       version = "0.0.0.1";
+       sha256 = "0sxw0fgrq83ahil1sa2mqndwxw7bjxya42sxym6jjsky9jr0mygl";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base bits-extra bytestring hw-bits hw-prim safe vector
+       ];
+       executableHaskellDepends = [
+         base bits-extra bytestring hw-bits hw-prim lens
+         optparse-applicative vector
+       ];
+       testHaskellDepends = [
+         base bits-extra bytestring hedgehog hspec hw-bits hw-hspec-hedgehog
+         hw-prim QuickCheck vector
+       ];
+       benchmarkHaskellDepends = [
+         base bits-extra bytestring criterion hw-bits hw-prim vector
+       ];
+       description = "File Dump";
+       license = stdenv.lib.licenses.bsd3;
      }) {};
 
   "hw-eliasfano" = callPackage
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "influxdb_1_6_1" = callPackage
+    ({ mkDerivation, aeson, attoparsec, base, bytestring, Cabal
+     , cabal-doctest, clock, containers, doctest, foldl, http-client
+     , http-types, lens, network, optional-args, QuickCheck, scientific
+     , tagged, template-haskell, text, time, unordered-containers
+     , vector
+     }:
+     mkDerivation {
+       pname = "influxdb";
+       version = "1.6.1";
+       sha256 = "1hfyp284lpvgy0rqn7rjr7c8z0ah8h0vl3xhfrff8x1z1511n2dp";
+       isLibrary = true;
+       isExecutable = true;
+       setupHaskellDepends = [ base Cabal cabal-doctest ];
+       libraryHaskellDepends = [
+         aeson attoparsec base bytestring clock containers foldl http-client
+         http-types lens network optional-args scientific tagged text time
+         unordered-containers vector
+       ];
+       testHaskellDepends = [ base doctest QuickCheck template-haskell ];
+       description = "Haskell client library for InfluxDB";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "informative" = callPackage
     ({ mkDerivation, base, containers, csv, highlighting-kate
      , http-conduit, monad-logger, pandoc, persistent
···
      }:
      mkDerivation {
        pname = "iri";
-       version = "0.3.4";
-       sha256 = "071vg01q5swwscvfsqqyk6ysqbl1yqpwnwklhj0h985sxv9zdkm6";
+       version = "0.3.4.1";
+       sha256 = "0lissbq0rajhds1s68shba227v0qsq51ffs171rnw31m92rn1c54";
        libraryHaskellDepends = [
          attoparsec base base-prelude bug bytestring contravariant hashable
          ip profunctors ptr punycode semigroups template-haskell text
···
     ({ mkDerivation, base, template-haskell }:
      mkDerivation {
        pname = "is";
-       version = "0.4.1";
-       sha256 = "1133npzv5rvcfxarafbmm6jfam45qdm3r33wc5qq920m0w60xi2a";
-       libraryHaskellDepends = [ base ];
+       version = "0.4.3";
+       sha256 = "1zw6pmfr2fyy6bghr1zx7gp62ywphnkcqkbql8yi6lgl0yq5qvh7";
+       libraryHaskellDepends = [ base template-haskell ];
        testHaskellDepends = [ base template-haskell ];
        description = "Generic pattern predicates";
        license = stdenv.lib.licenses.bsd3;
···
      , semigroupoids, tasty, tasty-hedgehog, tasty-hunit
      mkDerivation {
      , semigroupoids, tasty, tasty-hedgehog, tasty-hunit
-       version = "0.1.0.0";
-     , semigroupoids, tasty, tasty-hedgehog, tasty-hunit
+       version = "0.1.1.0";
+       sha256 = "07qzr2kkywqv47fjxyfxzklsai61pyb3q26lsbvxvnn0jqdg1z7a";
      , semigroupoids, tasty, tasty-hedgehog, tasty-hunit
      , semigroupoids, tasty, tasty-hedgehog, tasty-hunit
        license = stdenv.lib.licenses.bsd3;
···
      , semigroupoids, tasty, tasty-hedgehog, tasty-hunit
        license = "GPL";
        hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
+  "lambdabot-zulip" = callPackage
+    ({ mkDerivation, base, containers, hint, hspec, HUnit, hzulip
+     , mueval, optparse-applicative, say, text, yaml
+     }:
+     mkDerivation {
+       pname = "lambdabot-zulip";
+       version = "0.1.0";
+       sha256 = "1gjilhmkgbxdrf97mrfcmn84d8wx1g50k7sd27q5q2mldb4vr0xg";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base containers hint hzulip mueval optparse-applicative say text
+         yaml
+       ];
+       executableHaskellDepends = [ base ];
+       testHaskellDepends = [ base hspec HUnit text ];
+       description = "Lambdabot for Zulip Chat";
+       license = stdenv.lib.licenses.mit;
      }) {};
 
      , semigroupoids, tasty, tasty-hedgehog, tasty-hunit
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "leancheck_0_8_0" = callPackage
+    ({ mkDerivation, base, template-haskell }:
+     mkDerivation {
+       pname = "leancheck";
+       version = "0.8.0";
+       sha256 = "1lblxlg881asqgbdv6sivzxryis7cgkpclgyyks598ii06vd0z1s";
+       libraryHaskellDepends = [ base template-haskell ];
+       testHaskellDepends = [ base ];
+       description = "Enumerative property-based testing";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "leancheck-enum-instances" = callPackage
     ({ mkDerivation, base, enum-types, leancheck }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "list-tries";
-       version = "0.6.5";
-       sha256 = "1bdqja3favvxxlqxyh4r07xhkgsxan7lg8vb0nrahkfbifa4m6by";
+       version = "0.6.6";
+       sha256 = "0n837h2ffgqgram5kvnshlqk5jc87bw49z4pxa94qdmc323z51ak";
        libraryHaskellDepends = [ base binary containers dlist ];
        testHaskellDepends = [
          base binary ChasingBottoms HUnit QuickCheck template-haskell
···
      }) {};
 
   "list-zipper" = callPackage
-    ({ mkDerivation, base, checkers, comonad, deriving-compat, lens
-     , profunctors, QuickCheck, semigroupoids, semigroups, tasty
-     , tasty-hunit, tasty-quickcheck
+    ({ mkDerivation, base, checkers, comonad, deriving-compat, hedgehog
+     , hedgehog-fn, lens, mtl, QuickCheck, semigroupoids, semigroups
+     , tasty, tasty-hedgehog, tasty-hunit, tasty-quickcheck
+     , transformers
      }:
      mkDerivation {
        pname = "list-zipper";
-       version = "0.0.2";
-       sha256 = "1ylcknvp2i0rfl1anhjq7grbql2cz3ci5mxx5lbx7f9dl0fb6pb7";
+       version = "0.0.7";
+       sha256 = "1lbvj76bgsc1z0d3lzxrlam96i5z6jd8iymd06wlm313mdmkpgxy";
        libraryHaskellDepends = [
-         base comonad deriving-compat lens profunctors semigroupoids
-         semigroups
+         base comonad deriving-compat lens mtl semigroupoids semigroups
+         transformers
        ];
        testHaskellDepends = [
-         base checkers lens QuickCheck tasty tasty-hunit tasty-quickcheck
+         base checkers hedgehog hedgehog-fn lens mtl QuickCheck tasty
+         tasty-hedgehog tasty-hunit tasty-quickcheck transformers
        ];
        description = "A list zipper";
        license = stdenv.lib.licenses.bsd3;
···
        ];
        description = "Massiv (Массив) is an Array Library";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "massiv_0_2_4_0" = callPackage
+    ({ mkDerivation, base, bytestring, data-default, data-default-class
+     , deepseq, ghc-prim, hspec, primitive, QuickCheck, safe-exceptions
+     , vector
+     }:
+     mkDerivation {
+       pname = "massiv";
+       version = "0.2.4.0";
+       sha256 = "1zk8jkd4rng80spwha6xcmvszwjx2h8gd5xfa39zncdikd94l2hk";
+       libraryHaskellDepends = [
+         base bytestring data-default-class deepseq ghc-prim primitive
+         vector
+       ];
+       testHaskellDepends = [
+         base bytestring data-default deepseq hspec QuickCheck
+         safe-exceptions vector
+       ];
+       description = "Massiv (Массив) is an Array Library";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "massiv-io" = callPackage
···
      }:
      mkDerivation {
        pname = "multilinear";
-       version = "0.3.1.0";
-       sha256 = "04g70wv1vbz1hd81gjlbi16hlslmhlw9y4schjbwyq4b6ynkx28z";
+       version = "0.3.2.0";
+       sha256 = "0wjl4lzigbb7js99dd3i5kl081qqmrvk1w3kkjw7brasj8sqp01h";
        libraryHaskellDepends = [
          base containers deepseq mwc-random primitive statistics vector
        ];
···
        license = stdenv.lib.licenses.bsd3;
      }) {inherit (pkgs) mysql;};
 
+  "mysql_0_1_6" = callPackage
+    ({ mkDerivation, base, bytestring, Cabal, containers, hspec, mysql
+     }:
+     mkDerivation {
+       pname = "mysql";
+       version = "0.1.6";
+       sha256 = "1vlr4z3ng8sibb7g8363xlhff3811z8b5nmm0ljai6r5r5hrym4y";
+       setupHaskellDepends = [ base Cabal ];
+       libraryHaskellDepends = [ base bytestring containers ];
+       librarySystemDepends = [ mysql ];
+       testHaskellDepends = [ base bytestring hspec ];
+       description = "A low-level MySQL client library";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {inherit (pkgs) mysql;};
+
   "mysql-effect" = callPackage
     ({ mkDerivation, base, bytestring, extensible-effects, mysql
      , mysql-simple
···
      }:
      mkDerivation {
        pname = "nested-routes";
-       version = "9.0.1.1";
-       sha256 = "1s9jf5ik6m85nqjclj0m8ba41s3lfd93mqm6azynv7kg3cp9v4rl";
+       version = "9.0.2";
+       sha256 = "197q5fapwj5rnlqvwlzajjn8sjb960mgxqd7sbw2sih6cj63a9a2";
        libraryHaskellDepends = [
          attoparsec base errors exceptions extractable-singleton hashable
          monad-control-aligned mtl poly-arity pred-trie regex-compat text
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "oblivious-transfer" = callPackage
+    ({ mkDerivation, base, bytestring, cryptonite, memory, protolude
+     , QuickCheck, random, tasty, tasty-discover, tasty-hunit
+     , tasty-quickcheck
+     }:
+     mkDerivation {
+       pname = "oblivious-transfer";
+       version = "0.1.0";
+       sha256 = "1kq5ppm151q1im14j6zm2w0pn60baj6gzxmfqfx8p0m7a7wwl7sz";
+       libraryHaskellDepends = [
+         base bytestring cryptonite memory protolude random
+       ];
+       testHaskellDepends = [
+         base bytestring cryptonite memory protolude QuickCheck random tasty
+         tasty-discover tasty-hunit tasty-quickcheck
+       ];
+       testToolDepends = [ tasty-discover ];
+       description = "An implementation of the Oblivious Transfer protocol in Haskell";
+       license = stdenv.lib.licenses.asl20;
+     }) {};
+
   "observable" = callPackage
     ({ mkDerivation, async, base, transformers }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "pandoc-vimhl";
-       version = "0.1.1.0";
-       sha256 = "0xb7xz3b5vg9biq0zg1d4l3hkk6lxb6j9kzkrddy3h18yhnhzayf";
+       version = "0.1.2.4";
+       sha256 = "16gvlskbp2d000mbx2rkbz6dg6758ni4x2mkzxjyk5m475h13w6b";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
      }) {};
 
   "phaser" = callPackage
-    ({ mkDerivation, base, bytestring, containers, text }:
+    ({ mkDerivation, base, bytestring, containers, QuickCheck, text }:
      mkDerivation {
        pname = "phaser";
-       version = "1.0.0.1";
-       sha256 = "1ig3hcalfg2qxb092krii6zv95kvq0kng4acvq7l3wz03x66wj29";
+       version = "1.0.1.0";
+       sha256 = "0c4b5mx2nz8r0bpk29knzgs1hq5f69wsscplk7dcfsqwkngid930";
        libraryHaskellDepends = [ base bytestring containers text ];
+       testHaskellDepends = [
+         base bytestring containers QuickCheck text
+       ];
        description = "Incremental multiple pass parser library";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "picosat_0_1_5" = callPackage
+    ({ mkDerivation, base, containers, random, rdtsc, transformers }:
+     mkDerivation {
+       pname = "picosat";
+       version = "0.1.5";
+       sha256 = "0wc6zd1llyb880xvb8712b8mcil3arxnci68q2gmjb0gxa40jj6y";
+       libraryHaskellDepends = [ base containers transformers ];
+       testHaskellDepends = [ base containers random rdtsc transformers ];
+       description = "Bindings to the PicoSAT solver";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "pictikz" = callPackage
     ({ mkDerivation, base, matrix, transformers, xml }:
      mkDerivation {
···
        ];
        description = "Access to the Pinboard API";
        license = stdenv.lib.licenses.mit;
+     }) {};
+
+  "pinboard_0_9_12_11" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, containers, hspec
+     , http-client, http-client-tls, http-types, monad-logger, mtl
+     , network, profunctors, QuickCheck, random, safe-exceptions
+     , semigroups, text, time, transformers, unordered-containers
+     , vector
+     }:
+     mkDerivation {
+       pname = "pinboard";
+       version = "0.9.12.11";
+       sha256 = "12vj9lg7l2nb92j9mydsa8hcy0ql71qnphfhgdm30xrsps79vwd0";
+       libraryHaskellDepends = [
+         aeson base bytestring containers http-client http-client-tls
+         http-types monad-logger mtl network profunctors random
+         safe-exceptions text time transformers unordered-containers vector
+       ];
+       testHaskellDepends = [
+         aeson base bytestring containers hspec mtl QuickCheck
+         safe-exceptions semigroups text time transformers
+         unordered-containers
+       ];
+       description = "Access to the Pinboard API";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "pinch" = callPackage
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "postgresql-simple-migration_0_1_13_0" = callPackage
+    ({ mkDerivation, base, base64-bytestring, bytestring, cryptohash
+     , directory, hspec, postgresql-simple, text, time
+     }:
+     mkDerivation {
+       pname = "postgresql-simple-migration";
+       version = "0.1.13.0";
+       sha256 = "0rpcl6s1hwb5z0lkcrahh6ljx5zcb0aq8mrk691hfwazlhbv01zk";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base base64-bytestring bytestring cryptohash directory
+         postgresql-simple time
+       ];
+       executableHaskellDepends = [
+         base base64-bytestring bytestring cryptohash directory
+         postgresql-simple text time
+       ];
+       testHaskellDepends = [ base bytestring hspec postgresql-simple ];
+       description = "PostgreSQL Schema Migrations";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "postgresql-simple-opts" = callPackage
     ({ mkDerivation, base, bytestring, data-default, either
      , generic-deriving, hspec, optparse-applicative, optparse-generic
···
      }:
      mkDerivation {
        pname = "pred-trie";
-       version = "0.6.0.1";
-       sha256 = "0hymhjh7idpibzdx0214laf0zjf3a4anhsmxn0p5g9xkgh7l7m72";
+       version = "0.6.1";
+       sha256 = "1db4dw9d1r8z1qvwcv4q6imws65811skj5a04j032qbrnshsvjfr";
        libraryHaskellDepends = [
          base containers deepseq hashable hashtables mtl poly-arity pred-set
          QuickCheck semigroups strict tries unordered-containers
···
        pname = "pretty-sop";
        version = "0.2.0.2";
        sha256 = "0x1j5ngxwk176kr1qb0vr7zzjph1jxjc3bpzqcnph3rn2j6z4kyn";
-       revision = "1";
-       editedCabalFile = "16j80587sfq4hm2p24awcv388sm2snrwj3fhg9l3x256fbl4bm4s";
+       revision = "2";
+       editedCabalFile = "04hzf2ajlnh3ynk72xr5s396v8y0d8fkr4pf11nqss7yf60dkxwi";
        libraryHaskellDepends = [ base generics-sop pretty-show ];
        description = "A generic pretty-printer using generics-sop";
        license = stdenv.lib.licenses.bsd3;
···
        benchmarkHaskellDepends = [ base criterion deepseq ];
        description = "product-profunctors";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "prof-flamegraph" = callPackage
+    ({ mkDerivation, base, optparse-applicative }:
+     mkDerivation {
+       pname = "prof-flamegraph";
+       version = "1.0.0";
+       sha256 = "10ca6jmgnavqf8p8zf643rg1pjnzzndri4rbpmz6jshgy55vikf6";
+       isLibrary = false;
+       isExecutable = true;
+       executableHaskellDepends = [ base optparse-applicative ];
+       description = "Generate flamegraphs from ghc RTS .prof files";
+       license = stdenv.lib.licenses.mit;
      }) {};
 
   "prof2dot" = callPackage
···
      }:
      mkDerivation {
        pname = "purescript-iso";
-       version = "0.0.4";
-       sha256 = "1yqr8yfrc8vjn6h1wsfn0167ca6xj9wcl5a46zn9dklpkx995zyq";
+       version = "0.0.5";
+       sha256 = "06dw9fqc2h8asc3gwr3m5xqxsfcc24qw2pjz4wi2f2pgb32sicls";
        libraryHaskellDepends = [
          aeson aeson-attoparsec aeson-diff async attoparsec attoparsec-uri
          base bytestring containers deepseq emailaddress monad-control mtl
···
        pname = "records-sop";
        version = "0.1.0.2";
        sha256 = "187x3cq7h1rkmbv8qp810fcnr5y4byqwgw329v7f0s0px2vmg4h5";
+       revision = "1";
+       editedCabalFile = "082f4dmdvbnv6jq28mrva8clxif366vcbn9m8d1bb8lcf9h3qxjb";
        libraryHaskellDepends = [ base deepseq generics-sop ghc-prim ];
        testHaskellDepends = [
          base deepseq generics-sop hspec should-not-typecheck
···
 
   "ron" = callPackage
     ({ mkDerivation, aeson, attoparsec, base, binary, bytestring
-     , containers, criterion, data-default, deepseq, Diff, errors, extra
-     , hashable, mtl, safe, stringsearch, template-haskell, text, time
-     , unordered-containers, vector
+     , containers, criterion, data-default, deepseq, Diff, directory
+     , errors, extra, filepath, hashable, mtl, network-info, safe
+     , stringsearch, template-haskell, text, time, unordered-containers
+     , vector
      }:
      mkDerivation {
        pname = "ron";
-       version = "0.1";
-       sha256 = "1dwi0yyqzrwsl3x359hdpa5x77jqmbdidy0lx2wx2xlg0yzf5cfv";
+       version = "0.2";
+       sha256 = "1dv1lfz9v31k817cby0252jy08sd9c01l1jrlhqf243w25a6zp41";
        libraryHaskellDepends = [
          aeson attoparsec base binary bytestring containers data-default
-         deepseq Diff errors extra hashable mtl safe stringsearch
-         template-haskell text time unordered-containers vector
+         deepseq Diff directory errors extra filepath hashable mtl
+         network-info safe stringsearch template-haskell text time
+         unordered-containers vector
        ];
        benchmarkHaskellDepends = [ base criterion deepseq ];
        description = "RON, RON-RDT, and RON-Schema";
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
-  "serverless-haskell_0_8_2" = callPackage
+  "serverless-haskell_0_8_3" = callPackage
     ({ mkDerivation, aeson, aeson-casing, aeson-extra, amazonka-core
      , amazonka-kinesis, amazonka-s3, base, bytestring, case-insensitive
      , hspec, hspec-discover, http-types, iproute, lens, raw-strings-qq
···
      }:
      mkDerivation {
        pname = "serverless-haskell";
-       version = "0.8.2";
-       sha256 = "1ia1vjiw71qkqdpbna2jgxznwlhbh184fr5m95dcyl5kwwlb3nb8";
+       version = "0.8.3";
+       sha256 = "1d24qbl4d2sri9k67rgnivzw8wg5sxrdh2sh29m4wxvcas44a784";
        libraryHaskellDepends = [
          aeson aeson-casing aeson-extra amazonka-core amazonka-kinesis
          amazonka-s3 base bytestring case-insensitive http-types iproute
···
      }) {};
 
   "sets" = callPackage
-    ({ mkDerivation, base, commutative, composition, containers
-     , contravariant, criterion, hashable, keys, mtl, QuickCheck
-     , quickcheck-instances, semigroupoids, semigroups, tasty
-     , tasty-hunit, tasty-quickcheck, transformers, transformers-base
-     , unordered-containers, witherable
+    ({ mkDerivation, base, bytestring, commutative, composition
+     , containers, contravariant, criterion, hashable, keys, mtl
+     , QuickCheck, quickcheck-instances, semigroupoids, semigroups
+     , tasty, tasty-hunit, tasty-quickcheck, transformers
+     , transformers-base, unordered-containers, vector, witherable
      }:
      mkDerivation {
        pname = "sets";
-       version = "0.0.5.2";
-       sha256 = "04w7wisn9fzkg7wqfzmibd6myj3c4bvkx7w7i5q0nxx5njvxa85y";
+       version = "0.0.6";
+       sha256 = "0vnh4wy4p4x0jcxlwzj3mpxhkjv3igg2lphjgxj4dqzd2qddj63d";
        libraryHaskellDepends = [
-         base commutative composition containers contravariant hashable keys
-         mtl QuickCheck semigroupoids semigroups transformers
-         transformers-base unordered-containers witherable
+         base bytestring commutative composition containers contravariant
+         hashable keys mtl QuickCheck semigroupoids semigroups transformers
+         transformers-base unordered-containers vector witherable
        ];
        testHaskellDepends = [
-         base commutative containers contravariant QuickCheck
-         quickcheck-instances tasty tasty-hunit tasty-quickcheck
-         unordered-containers
+         base bytestring commutative composition containers contravariant
+         hashable keys mtl QuickCheck quickcheck-instances semigroupoids
+         semigroups tasty tasty-hunit tasty-quickcheck transformers
+         transformers-base unordered-containers vector witherable
        ];
        benchmarkHaskellDepends = [
-         base commutative containers contravariant criterion
-         unordered-containers
+         base bytestring commutative composition containers contravariant
+         criterion hashable keys mtl QuickCheck semigroupoids semigroups
+         transformers transformers-base unordered-containers vector
+         witherable
        ];
        description = "Ducktyped set interface for Haskell containers";
-       license = stdenv.lib.licenses.mit;
+       license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
···
        maintainers = with stdenv.lib.maintainers; [ psibi ];
      }) {};
 
+  "shakespeare_2_0_20" = callPackage
+    ({ mkDerivation, aeson, base, blaze-html, blaze-markup, bytestring
+     , containers, directory, exceptions, ghc-prim, hspec, HUnit, parsec
+     , process, scientific, template-haskell, text, time, transformers
+     , unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "shakespeare";
+       version = "2.0.20";
+       sha256 = "00wybn9dcwi2y1cp87fyvhcqn8filvb8as7k78g1m1c5wpwby3pm";
+       libraryHaskellDepends = [
+         aeson base blaze-html blaze-markup bytestring containers directory
+         exceptions ghc-prim parsec process scientific template-haskell text
+         time transformers unordered-containers vector
+       ];
+       testHaskellDepends = [
+         aeson base blaze-html blaze-markup bytestring containers directory
+         exceptions ghc-prim hspec HUnit parsec process template-haskell
+         text time transformers
+       ];
+       description = "A toolkit for making compile-time interpolated templates";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       maintainers = with stdenv.lib.maintainers; [ psibi ];
+     }) {};
+
   "shakespeare-babel" = callPackage
     ({ mkDerivation, base, classy-prelude, data-default, directory
      , process, shakespeare, template-haskell
···
      }:
      mkDerivation {
        pname = "simple-effects";
-       version = "0.12.0.0";
-       sha256 = "1k7wslyiv0hqpq7b92xyxlv3a1431cbaraxiw1ircjrm3ay28bd0";
+       version = "0.13.0.0";
+       sha256 = "14ik7rw9qszfq010g6c951r59g1gds3lpczsrqi4gq932s1rr4rn";
+       revision = "1";
+       editedCabalFile = "15zca24ldx643cyp1f7l5d69g3micqrha2sk5arz5xygxhas2yrm";
        libraryHaskellDepends = [
          array async base bytestring exceptions list-t monad-control
          MonadRandom mtl text transformers transformers-base
···
 
   "sized-grid" = callPackage
     ({ mkDerivation, adjunctions, aeson, ansi-terminal, base, comonad
-     , constraints, distributive, generics-sop, hedgehog, HUnit, lens
-     , markdown-unlit, mtl, random, tasty, tasty-hedgehog, tasty-hunit
-     , vector, vector-space
+     , constraints, distributive, generics-sop, HUnit, lens
+     , markdown-unlit, mtl, QuickCheck, random, tasty, tasty-hunit
+     , tasty-quickcheck, vector, vector-space
      }:
      mkDerivation {
        pname = "sized-grid";
-       version = "0.1.1.1";
-       sha256 = "0v3350z1p9bmwancn205jbbqj1wwi7f6415jzz3fcypkmyq90bav";
+       version = "0.1.1.6";
+       sha256 = "06qbbih3gn92b85aqk7qx8q4yg56jqh9ncczb66q6sn599xay1s9";
        libraryHaskellDepends = [
          adjunctions aeson base comonad constraints distributive
          generics-sop lens mtl random vector vector-space
        ];
        testHaskellDepends = [
          adjunctions aeson ansi-terminal base comonad distributive
-         generics-sop hedgehog HUnit lens markdown-unlit tasty
-         tasty-hedgehog tasty-hunit vector-space
+         generics-sop HUnit lens markdown-unlit QuickCheck tasty tasty-hunit
+         tasty-quickcheck vector vector-space
        ];
        testToolDepends = [ markdown-unlit ];
        description = "Multidimensional grids with sized specified at compile time";
···
      }) {};
 
   "solve" = callPackage
-    ({ mkDerivation, base, containers, filepath }:
+    ({ mkDerivation, base, containers, filepath, QuickCheck }:
      mkDerivation {
        pname = "solve";
-       version = "1.1";
-       sha256 = "045bj6wskglwg0j0jk0jsqkp4m809g2fy350bi6m84smg64rr3y4";
+       version = "1.2";
+       sha256 = "03byni7iqv9wh35bc2g94ycsm1nl0ngfs4n1nkpprd1vw0d5g9h4";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base containers filepath ];
        executableHaskellDepends = [ base containers filepath ];
+       testHaskellDepends = [ base containers QuickCheck ];
        description = "Solving simple games";
        license = stdenv.lib.licenses.mit;
      }) {};
···
      }:
      mkDerivation {
        pname = "sparrow";
-       version = "0.0.2.2";
-       sha256 = "0y1s22nfy234jgvvkxc77x0gcrlqb1g5vqni6vdwls6ww9n1jwba";
+       version = "0.0.3";
+       sha256 = "0rwspgmy4s33viijxb4rqck7qdwrxn15k54cbccijncqjpc15azj";
        libraryHaskellDepends = [
          aeson aeson-attoparsec async attoparsec attoparsec-uri base
          bytestring deepseq exceptions extractable-singleton hashable
···
        ];
        description = "Streaming interfaces for `store`";
        license = stdenv.lib.licenses.mit;
+     }) {};
+
+  "stp" = callPackage
+    ({ mkDerivation, base, containers, regex-compat }:
+     mkDerivation {
+       pname = "stp";
+       version = "0.1.0.0";
+       sha256 = "1anajnwakr3j2yixjjq2clk36b5043hpr0kfqm6qahj62hcdq9wm";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [ base containers ];
+       executableHaskellDepends = [ base regex-compat ];
+       description = "Simple Theorem Prover";
+       license = stdenv.lib.licenses.bsd3;
      }) {};
 
   "str" = callPackage
···
        pname = "supervisors";
        version = "0.1.0.0";
        sha256 = "1sxralp0hcz2zn5byn67xq612nzmpm890gnjs827sidvr7r7h31j";
-       revision = "1";
-       editedCabalFile = "186a5vawnknixf4psp06cjbyby5qp4i0c8bpvisqi3pq3kag7x76";
+       revision = "2";
+       editedCabalFile = "08qz4qbfrj7hpk3pgyjy3r149dz48jpxajyjs10fgiz16xg11zyl";
        libraryHaskellDepends = [ async base containers stm unliftio ];
        testHaskellDepends = [ base hspec ];
        description = "Monitor groups of threads with non-hierarchical lifetimes";
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
-  "tar-conduit_0_3_0" = callPackage
+  "tar-conduit_0_3_1" = callPackage
     ({ mkDerivation, base, bytestring, conduit, conduit-combinators
      , conduit-extra, containers, criterion, deepseq, directory
      , filepath, hspec, QuickCheck, safe-exceptions, text, unix, weigh
      }:
      mkDerivation {
        pname = "tar-conduit";
-       version = "0.3.0";
-       sha256 = "0g35wiqn0bi31sqnzknq90iy265c7lw15rkyrzc6c2vp6nl86j08";
+       version = "0.3.1";
+       sha256 = "15w1qs276x2j13s3dg5a0d8jjcs3rf8hhnfa2m6p8jm7kjirvahm";
        libraryHaskellDepends = [
          base bytestring conduit conduit-combinators directory filepath
          safe-exceptions text unix
···
      }) {};
 
   "tries" = callPackage
-    ({ mkDerivation, base, bytestring, bytestring-trie, composition
-     , containers, criterion, deepseq, hashable, keys, mtl, QuickCheck
+    ({ mkDerivation, base, bytestring, composition, containers
+     , criterion, deepseq, hashable, keys, mtl, QuickCheck
      , quickcheck-instances, rose-trees, semigroups, sets, tasty
      , tasty-quickcheck, unordered-containers
      }:
      mkDerivation {
        pname = "tries";
-       version = "0.0.5";
-       sha256 = "1xljwkdwfwd962f7bdbds89m93hw24b54624d4fqlq4n0dyq50x0";
+       version = "0.0.6";
+       sha256 = "0765my34c8fcd8ri9acrcymgpjfqqq7a98zr94z8czrnh5zsmzjv";
        libraryHaskellDepends = [
-         base bytestring bytestring-trie composition containers deepseq
-         hashable keys QuickCheck quickcheck-instances rose-trees semigroups
-         sets unordered-containers
+         base bytestring composition containers deepseq hashable keys
+         QuickCheck quickcheck-instances rose-trees semigroups sets
+         unordered-containers
        ];
        testHaskellDepends = [
-         base bytestring bytestring-trie composition containers deepseq
-         hashable keys mtl QuickCheck quickcheck-instances rose-trees
-         semigroups sets tasty tasty-quickcheck unordered-containers
+         base bytestring composition containers deepseq hashable keys mtl
+         QuickCheck quickcheck-instances rose-trees semigroups sets tasty
+         tasty-quickcheck unordered-containers
        ];
        benchmarkHaskellDepends = [
-         base bytestring bytestring-trie composition containers criterion
-         deepseq hashable keys mtl QuickCheck quickcheck-instances
-         rose-trees semigroups sets unordered-containers
+         base bytestring composition containers criterion deepseq hashable
+         keys mtl QuickCheck quickcheck-instances rose-trees semigroups sets
+         unordered-containers
        ];
        description = "Various trie implementations in Haskell";
        license = stdenv.lib.licenses.bsd3;
···
        license = stdenv.lib.licenses.asl20;
      }) {};
 
+  "tz_0_1_3_2" = callPackage
+    ({ mkDerivation, base, binary, bytestring, containers, criterion
+     , data-default, deepseq, HUnit, lens, QuickCheck, template-haskell
+     , test-framework, test-framework-hunit, test-framework-quickcheck2
+     , test-framework-th, thyme, time, timezone-olson, timezone-series
+     , tzdata, vector
+     }:
+     mkDerivation {
+       pname = "tz";
+       version = "0.1.3.2";
+       sha256 = "0k35pw27a3hwg5wqjpfqij0y7rkdlmd85n4kj4ckna4z2v86dl7h";
+       libraryHaskellDepends = [
+         base binary bytestring containers data-default deepseq
+         template-haskell time tzdata vector
+       ];
+       testHaskellDepends = [
+         base HUnit QuickCheck test-framework test-framework-hunit
+         test-framework-quickcheck2 test-framework-th time tzdata
+       ];
+       benchmarkHaskellDepends = [
+         base criterion lens thyme time timezone-olson timezone-series
+       ];
+       preConfigure = "export TZDIR=${pkgs.tzdata}/share/zoneinfo";
+       description = "Efficient time zone handling";
+       license = stdenv.lib.licenses.asl20;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "tzdata" = callPackage
     ({ mkDerivation, base, bytestring, containers, deepseq, HUnit
      , test-framework, test-framework-hunit, test-framework-th, unix
···
        ];
        description = "Time zone database (as files and as a module)";
        license = stdenv.lib.licenses.asl20;
+     }) {};
+
+  "tzdata_0_1_20181026_0" = callPackage
+    ({ mkDerivation, base, bytestring, containers, deepseq, HUnit
+     , test-framework, test-framework-hunit, test-framework-th, unix
+     , vector
+     }:
+     mkDerivation {
+       pname = "tzdata";
+       version = "0.1.20181026.0";
+       sha256 = "0b531ydcb63q44zjpcd2l70xp2hgkxqppnfld7n16ifh9vrxm6gf";
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         base bytestring containers deepseq vector
+       ];
+       testHaskellDepends = [
+         base bytestring HUnit test-framework test-framework-hunit
+         test-framework-th unix
+       ];
+       description = "Time zone database (as files and as a module)";
+       license = stdenv.lib.licenses.asl20;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "u2f" = callPackage
···
      }:
      mkDerivation {
        pname = "unjson";
-       version = "0.15.2.0";
-       sha256 = "040s1b9frl0sj8saa9b0bzsnqhmb4vdrscff2jzzcdn0papn5rbj";
-       revision = "1";
-       editedCabalFile = "1kv5ybjgpqxq7xy8x1rgr8ia7kaffgih0z7jx74ixdijkqk69447";
+       version = "0.15.2.1";
+       sha256 = "1zx66qjx4rikbs8f2j1vazasin5fr6pxks3j5b7fkpriyxk49khs";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring containers free hashable invariant
          pretty primitive scientific semigroups text time
···
      }:
      mkDerivation {
        pname = "waargonaut";
-       version = "0.3.0.0";
-       sha256 = "09svy408l8vy40a91mqpzpkslans0ppkvmqkgaihnc929wdwfkf6";
+       version = "0.4.1.0";
+       sha256 = "018x0rb86ndshaqm0ns2cjwrqs2d2sq5sqypy1nbd8rh1g943cdn";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [
          base bifunctors bytestring containers contravariant digit
···
          transformers vector witherable wl-pprint-annotated zippers
        ];
        testHaskellDepends = [
-         attoparsec base bytestring containers digit directory distributive
-         doctest filepath generics-sop hedgehog hedgehog-fn lens mtl natural
-         scientific semigroupoids semigroups tagged tasty
+         attoparsec base bytestring containers contravariant digit directory
+         distributive doctest filepath generics-sop hedgehog hedgehog-fn
+         lens mtl natural scientific semigroupoids semigroups tagged tasty
          tasty-expected-failure tasty-hedgehog tasty-hunit template-haskell
          text vector zippers
        ];
···
      }:
      mkDerivation {
        pname = "wai-middleware-content-type";
-       version = "0.6.1.2";
-       sha256 = "057xrb6nik8imxg91chyhakddb0ywm7ccfkwjlyrbwrd5hm84j8r";
+       version = "0.6.2";
+       sha256 = "18ay8ng3gmyn25iziwlw82z5vbbkc6pgp5d0iz29qmc2lm6y6wgw";
        libraryHaskellDepends = [
          aeson base blaze-builder blaze-html bytestring clay exceptions
          extractable-singleton hashable http-media http-types lucid mmorph
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
-  "web3_0_8_2_0" = callPackage
+  "web3_0_8_2_1" = callPackage
     ({ mkDerivation, aeson, async, base, basement, bytestring, cereal
      , cryptonite, data-default, exceptions, generics-sop, hspec
      , hspec-contrib, hspec-discover, hspec-expectations, http-client
···
      }:
      mkDerivation {
        pname = "web3";
-       version = "0.8.2.0";
-       sha256 = "0gfz4011yflpjhg2397wq5761hq4r0g0yrkqljp1xsikq2jab72h";
+       version = "0.8.2.1";
+       sha256 = "1dcv7977r98lrwh12si9vzvm5bcjdyfdivl63r5zwkykapd15z00";
        libraryHaskellDepends = [
          aeson async base basement bytestring cereal cryptonite data-default
          exceptions generics-sop http-client http-client-tls machines memory
···
      }:
      mkDerivation {
        pname = "websockets-simple";
-       version = "0.1.2.1";
-       sha256 = "1g3cqbdycjx82px06xvh4q3jjnp71llzsw4v0s815933fgfcck54";
+       version = "0.1.3";
+       sha256 = "1nknnb7zmkcm377q9i9whcw4fd43q2nk5vla2yilr9lnp5g4gqr0";
        libraryHaskellDepends = [
          aeson async base bytestring exceptions extractable-singleton
          monad-control-aligned profunctors stm transformers vector
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "yesod-auth-hashdb_1_7_1" = callPackage
+    ({ mkDerivation, aeson, base, basic-prelude, bytestring, containers
+     , hspec, http-conduit, http-types, monad-logger, network-uri
+     , persistent, persistent-sqlite, resourcet, text
+     , unordered-containers, wai-extra, yesod, yesod-auth, yesod-core
+     , yesod-form, yesod-persistent, yesod-test
+     }:
+     mkDerivation {
+       pname = "yesod-auth-hashdb";
+       version = "1.7.1";
+       sha256 = "1rfz2xanm6d70fx8ywh8j8py8003akzgi10s9n7syqm8kaj2fvqd";
+       libraryHaskellDepends = [
+         aeson base bytestring persistent text yesod-auth yesod-core
+         yesod-form yesod-persistent
+       ];
+       testHaskellDepends = [
+         aeson base basic-prelude bytestring containers hspec http-conduit
+         http-types monad-logger network-uri persistent-sqlite resourcet
+         text unordered-containers wai-extra yesod yesod-auth yesod-core
+         yesod-test
+       ];
+       description = "Authentication plugin for Yesod";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "yesod-auth-hmac-keccak" = callPackage
     ({ mkDerivation, aeson, base, bytestring, cryptonite, mtl
      , persistent, random, shakespeare, text, yesod-auth, yesod-core
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
-  "yesod-form-bootstrap4_2_0_0" = callPackage
+  "yesod-form-bootstrap4_2_1_0" = callPackage
     ({ mkDerivation, base, text, yesod-core, yesod-form }:
      mkDerivation {
        pname = "yesod-form-bootstrap4";
-       version = "2.0.0";
-       sha256 = "19aiifq8rmdjlzl1slh3rqhggp6h52nsb6v9wnhpi6c3nq4l2paf";
+       version = "2.1.0";
+       sha256 = "1wf1jbhfs4f75977rnrrkahgysxqrcas4qi1ay1ggq29hp1z4hic";
        libraryHaskellDepends = [ base text yesod-core yesod-form ];
        description = "renderBootstrap4";
        license = stdenv.lib.licenses.mit;

pkgs/development/libraries/arb/git.nix

···
-{stdenv, fetchFromGitHub, mpir, gmp, mpfr, flint}:
-stdenv.mkDerivation rec {
-  name = "${pname}-${version}";
-  pname = "arb";
-  version = "2.9.0pre20161013";
-  src = fetchFromGitHub {
-    owner = "fredrik-johansson";
-    repo = "${pname}";
-    rev = "10bc615ce5999caf4723444b2b1219b74781d8a4";
-    sha256 = "1xb40x3hv9nh76aizhskj5gdhalgn7r95a7zji2nn4ih3lmh40hl";
-  };
-  buildInputs = [ mpir gmp mpfr flint ];
-  configureFlags = [ "--with-gmp=${gmp}" "--with-mpir=${mpir}" "--with-mpfr=${mpfr}" "--with-flint=${flint}" ];
-  meta = {
-    inherit version;
-    description = ''A library for arbitrary-precision interval arithmetic'';
-    license = stdenv.lib.licenses.lgpl21Plus;
-    maintainers = [stdenv.lib.maintainers.raskin];
-    platforms = stdenv.lib.platforms.linux;
-  };
-}

pkgs/development/libraries/fltk/1.4.nix

···
+{ stdenv, fetchurl, pkgconfig, xlibsWrapper, inputproto, libXi
+, freeglut, libGLU_combined, libjpeg, zlib, libXft, libpng
+, libtiff, freetype, cf-private, Cocoa, AGL, GLUT
+}:
+
+let
+  version = "1.4.x-r13121";
+in stdenv.mkDerivation {
+  name = "fltk-${version}";
+
+  src = fetchurl {
+    url = "http://fltk.org/pub/fltk/snapshots/fltk-${version}.tar.gz";
+    sha256 = "1v8wxvxcbk99i82x2v5fpqg5vj8n7g8a38g30ry7nzcjn5sf3r63";
+  };
+
+  preConfigure = "make clean";
+
+  patches = stdenv.lib.optionals stdenv.isDarwin [ ./nsosv.patch ];
+
+  nativeBuildInputs = [ pkgconfig ];
+
+  buildInputs = [
+    libGLU_combined
+    libjpeg
+    zlib
+    libpng
+    libXft
+  ];
+
+  configureFlags = [
+    "--enable-gl"
+    "--enable-largefile"
+    "--enable-shared"
+    "--enable-threads"
+    "--enable-xft"
+  ];
+
+  propagatedBuildInputs = [ inputproto ]
+    ++ (if stdenv.isDarwin
+        then [ Cocoa AGL GLUT freetype libtiff cf-private  /* Needed for NSDefaultRunLoopMode */ ]
+        else [ xlibsWrapper libXi freeglut ]);
+
+  enableParallelBuilding = true;
+
+  meta = {
+    description = "A C++ cross-platform lightweight GUI library";
+    homepage = http://www.fltk.org;
+    platforms = stdenv.lib.platforms.linux ++ stdenv.lib.platforms.darwin;
+    license = stdenv.lib.licenses.gpl2;
+  };
+
+}

pkgs/development/libraries/git2/default.nix

···
 
 stdenv.mkDerivation (rec {
   name = "libgit2-${version}";
-  version = "0.26.6";
+  version = "0.26.8";
   # keep the version in sync with pythonPackages.pygit2 and gnome3.libgit2-glib
 
   src = fetchFromGitHub {
     owner = "libgit2";
     repo = "libgit2";
     rev = "v${version}";
-    sha256 = "17pjvprmdrx4h6bb1hhc98w9qi6ki7yl57f090n9kbhswxqfs7s3";
+    sha256 = "0wmjgvz8nrpk2dsn5bcc87nl0j5hb6pah2hzrj0b6jkk9mnin9fl";
   };
 
   cmakeFlags = [ "-DTHREADSAFE=ON" ];

pkgs/development/libraries/libvpx/git.nix

···
-{ stdenv, fetchgit, perl, yasm
-, vp8DecoderSupport ? true # VP8 decoder
-, vp8EncoderSupport ? true # VP8 encoder
-, vp9DecoderSupport ? true # VP9 decoder
-, vp9EncoderSupport ? true # VP9 encoder
-, extraWarningsSupport ? false # emit non-fatal warnings
-, werrorSupport ? false # treat warnings as errors (not available with all compilers)
-, debugSupport ? false # debug mode
-, gprofSupport ? false # gprof profiling instrumentation
-, gcovSupport ? false # gcov coverage instrumentation
-, sizeLimitSupport ? true # limit max size to allow in the decoder
-, optimizationsSupport ? true # compiler optimization flags
-, runtimeCpuDetectSupport ? true # detect cpu capabilities at runtime
-, thumbSupport ? false # build arm assembly in thumb mode
-, examplesSupport ? true # build examples (vpxdec & vpxenc are part of examples)
-, fastUnalignedSupport ? true # use unaligned accesses if supported by hardware
-, debugLibsSupport ? false # include debug version of each library
-, postprocSupport ? true # postprocessing
-, multithreadSupport ? true # multithreaded decoding & encoding
-, internalStatsSupport ? false # output of encoder internal stats for debug, if supported (encoders)
-, memTrackerSupport ? false # track memory usage
-, spatialResamplingSupport ? true # spatial sampling (scaling)
-, realtimeOnlySupport ? false # build for real-time encoding
-, ontheflyBitpackingSupport ? false # on-the-fly bitpacking in real-time encoding
-, errorConcealmentSupport ? false # decoder conceals losses
-, smallSupport ? false # favor smaller binary over speed
-, postprocVisualizerSupport ? false # macro block/block level visualizers
-, unitTestsSupport ? false, curl ? null, coreutils ? null # unit tests
-, webmIOSupport ? true # input from and output to webm container
-, libyuvSupport ? true # libyuv
-, decodePerfTestsSupport ? false # build decoder perf tests with unit tests
-, encodePerfTestsSupport ? false # build encoder perf tests with unit tests
-, multiResEncodingSupport ? false # multiple-resolution encoding
-, temporalDenoisingSupport ? true # use temporal denoising instead of spatial denoising
-, coefficientRangeCheckingSupport ? false # decoder checks if intermediate transform coefficients are in valid range
-, vp9HighbitdepthSupport ? true # 10/12 bit color support in VP9
-# Experimental features
-, experimentalSpatialSvcSupport ? false # Spatial scalable video coding
-, experimentalFpMbStatsSupport ? false
-, experimentalEmulateHardwareSupport ? false
-}:
-
-let
-  inherit (stdenv) isi686 isx86_64 isAarch32 is64bit isMips isDarwin isCygwin;
-  inherit (stdenv.lib) enableFeature optional optionals;
-in
-
-assert isi686 || isx86_64 || isAarch32 || isMips; # Requires ARM with floating point support
-
-assert vp8DecoderSupport || vp8EncoderSupport || vp9DecoderSupport || vp9EncoderSupport;
-assert internalStatsSupport && (vp9DecoderSupport || vp9EncoderSupport) -> postprocSupport;
-/* If spatialResamplingSupport not enabled, build will fail with undeclared variable errors.
-   Variables called in vpx_scale/generic/vpx_scale.c are declared by vpx_scale/vpx_scale_rtcd.pl,
-   but is only executed if spatialResamplingSupport is enabled */
-assert spatialResamplingSupport;
-assert postprocVisualizerSupport -> postprocSupport;
-assert unitTestsSupport -> curl != null && coreutils != null;
-assert vp9HighbitdepthSupport -> (vp9DecoderSupport || vp9EncoderSupport);
-assert isCygwin -> unitTestsSupport && webmIOSupport && libyuvSupport;
-
-stdenv.mkDerivation rec {
-  name = "libvpx-git-${version}";
-  version = "2015-2-12";
-
-  src = fetchgit {
-    url = "https://chromium.googlesource.com/webm/libvpx";
-  /* DO NOT under any circumstance ever just bump the git commit without
-     confirming changes have not been made to the configure system */
-    rev = "f4c29ae9ea16c502c980a81ca9683327d5051929";
-    sha256 = "1w17vpcy44wlpr2icbwhcf3mrinybwy0bhif30p707hbxfxrj474";
-  };
-
-  patchPhase = ''patchShebangs .'';
-
-  outputs = [ "bin" "dev" "out" ];
-  setOutputFlags = false;
-
-  configurePlatforms = [];
-  configureFlags = [
-    (enableFeature (vp8EncoderSupport || vp8DecoderSupport) "vp8")
-    (enableFeature vp8EncoderSupport "vp8-encoder")
-    (enableFeature vp8DecoderSupport "vp8-decoder")
-    (enableFeature (vp9EncoderSupport || vp9DecoderSupport) "vp9")
-    (enableFeature vp9EncoderSupport "vp9-encoder")
-    (enableFeature vp9DecoderSupport "vp9-decoder")
-    (enableFeature extraWarningsSupport "extra-warnings")
-    (enableFeature werrorSupport "werror")
-    "--disable-install-docs"
-    (enableFeature examplesSupport "install-bins")
-    "--enable-install-libs"
-    "--disable-install-srcs"
-    (enableFeature debugSupport "debug")
-    (enableFeature gprofSupport "gprof")
-    (enableFeature gcovSupport "gcov")
-    # Required to build shared libraries
-    (enableFeature (!isCygwin) "pic")
-    (enableFeature (isi686 || isx86_64) "use-x86inc")
-    (enableFeature optimizationsSupport "optimizations")
-    (enableFeature runtimeCpuDetectSupport "runtime-cpu-detect")
-    (enableFeature thumbSupport "thumb")
-    "--enable-libs"
-    (enableFeature examplesSupport "examples")
-    "--disable-docs"
-    "--as=yasm"
-    # Limit default decoder max to WHXGA
-    (if sizeLimitSupport then "--size-limit=5120x3200" else null)
-    (enableFeature fastUnalignedSupport "fast-unaligned")
-    "--disable-codec-srcs"
-    (enableFeature debugLibsSupport "debug-libs")
-    (enableFeature isMips "dequant-tokens")
-    (enableFeature isMips "dc-recon")
-    (enableFeature postprocSupport "postproc")
-    (enableFeature (postprocSupport && (vp9DecoderSupport || vp9EncoderSupport)) "vp9-postproc")
-    (enableFeature multithreadSupport "multithread")
-    (enableFeature internalStatsSupport "internal-stats")
-    (enableFeature memTrackerSupport "mem-tracker")
-    (enableFeature spatialResamplingSupport "spatial-resampling")
-    (enableFeature realtimeOnlySupport "realtime-only")
-    (enableFeature ontheflyBitpackingSupport "onthefly-bitpacking")
-    (enableFeature errorConcealmentSupport "error-concealment")
-    # Shared libraries are only supported on ELF platforms
-    (if isDarwin || isCygwin then
-       "--enable-static --disable-shared"
-     else
-       "--disable-static --enable-shared")
-    (enableFeature smallSupport "small")
-    (enableFeature postprocVisualizerSupport "postproc-visualizer")
-    (enableFeature unitTestsSupport "unit-tests")
-    (enableFeature webmIOSupport "webm-io")
-    (enableFeature libyuvSupport "libyuv")
-    (enableFeature decodePerfTestsSupport "decode-perf-tests")
-    (enableFeature encodePerfTestsSupport "encode-perf-tests")
-    (enableFeature multiResEncodingSupport "multi-res-encoding")
-    (enableFeature temporalDenoisingSupport "temporal-denoising")
-    (enableFeature (temporalDenoisingSupport && (vp9DecoderSupport || vp9EncoderSupport)) "vp9-temporal-denoising")
-    (enableFeature coefficientRangeCheckingSupport "coefficient-range-checking")
-    (enableFeature (vp9HighbitdepthSupport && is64bit) "vp9-highbitdepth")
-    (enableFeature (experimentalSpatialSvcSupport ||
-                    experimentalFpMbStatsSupport ||
-                    experimentalEmulateHardwareSupport) "experimental")
-  ] ++ optionals (stdenv.hostPlatform != stdenv.buildPlatform) [
-      #"--extra-cflags="
-      #"--prefix="
-      #"--libc="
-      #"--libdir="
-      "--enable-external-build"
-      # libvpx darwin targets include darwin version (ie. ARCH-darwinXX-gcc, XX being the darwin version)
-      # See all_platforms: https://github.com/webmproject/libvpx/blob/master/configure
-      # Darwin versions: 10.4=8, 10.5=9, 10.6=10, 10.7=11, 10.8=12, 10.9=13, 10.10=14
-      "--force-target=${stdenv.hostPlatform.config}${
-              if stdenv.hostPlatform.isDarwin then
-                if      stdenv.hostPlatform.osxMinVersion == "10.10" then "14"
-                else if stdenv.hostPlatform.osxMinVersion == "10.9"  then "13"
-                else if stdenv.hostPlatform.osxMinVersion == "10.8"  then "12"
-                else if stdenv.hostPlatform.osxMinVersion == "10.7"  then "11"
-                else if stdenv.hostPlatform.osxMinVersion == "10.6"  then "10"
-                else if stdenv.hostPlatform.osxMinVersion == "10.5"  then "9"
-                else "8"
-              else ""}-gcc"
-      (if stdenv.hostPlatform.isCygwin then "--enable-static-msvcrt" else "")
-  ] # Experimental features
-    ++ optional experimentalSpatialSvcSupport "--enable-spatial-svc"
-    ++ optional experimentalFpMbStatsSupport "--enable-fp-mb-stats"
-    ++ optional experimentalEmulateHardwareSupport "--enable-emulate-hardware";
-
-  nativeBuildInputs = [ perl yasm ];
-
-  buildInputs = [ ]
-    ++ optionals unitTestsSupport [ coreutils curl ];
-
-  enableParallelBuilding = true;
-
-  postInstall = ''moveToOutput bin "$bin" '';
-
-  meta = with stdenv.lib; {
-    description = "WebM VP8/VP9 codec SDK";
-    homepage    = https://www.webmproject.org/;
-    license     = licenses.bsd3;
-    maintainers = with maintainers; [ codyopel ];
-    platforms   = platforms.all;
-  };
-}

pkgs/development/libraries/physics/fastjet/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "fastjet-${version}";
-  version = "3.3.1";
+  version = "3.3.2";
 
   src = fetchurl {
     url = "http://fastjet.fr/repo/fastjet-${version}.tar.gz";
-    sha256 = "0lvchyh9q2p8lb10isazw0wbwzs24yg7gxyhpj9xpvz5hydyvgvn";
+    sha256 = "1hk3k7dyik640dzg21filpywc2dl862nl2hbpg384hf5pw9syn9z";
   };
 
   buildInputs = [ python2 ];
-
-  postPatch = ''
-    substituteInPlace plugins/SISCone/SISConeBasePlugin.cc \
-      --replace 'structure_of<UserScaleBase::StructureType>()' \
-                'structure_of<UserScaleBase>()'
-  '';
 
   configureFlags = [
     "--enable-allcxxplugins"

pkgs/development/libraries/physics/herwig/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "herwig-${version}";
-  version = "7.1.3";
+  version = "7.1.4";
 
   src = fetchurl {
     url = "https://www.hepforge.org/archive/herwig/Herwig-${version}.tar.bz2";
-    sha256 = "1iq1h5ap86729c4pfkswzfh0l2v20fyvqsb15c35g0407l54wfqm";
+    sha256 = "1awr1jz0q873x8bgwiilzklhk1zkgm6slvpychpnvsf9vk05mmdx";
   };
 
   nativeBuildInputs = [ autoconf automake libtool ];
···
     homepage    = https://herwig.hepforge.org/;
     platforms   = stdenv.lib.platforms.unix;
     maintainers = with stdenv.lib.maintainers; [ veprbl ];
+    broken      = stdenv.isAarch64; # doesn't compile: ignoring return value of 'FILE* freopen...
   };
 }

pkgs/development/libraries/physics/thepeg/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "thepeg-${version}";
-  version = "2.1.3";
+  version = "2.1.4";
 
   src = fetchurl {
     url = "https://www.hepforge.org/archive/thepeg/ThePEG-${version}.tar.bz2";
-    sha256 = "030wpk78mwb56iph5iqmblsxgzpydsa25bbkv07bihihfm8gds0n";
+    sha256 = "1x9dfxmsbmzmsxrv3cczfyrnqkxjcpy89v6v7ycysrx9k8qkf320";
   };
 
   buildInputs = [ boost fastjet gsl hepmc lhapdf rivet zlib ];

pkgs/development/libraries/qt-5/modules/qtwebkit.nix

···
     ++ optional (stdenv.isDarwin && lib.versionAtLeast qtbase.version "5.9.0") qtmultimedia
     ++ optional (lib.versionAtLeast qtbase.version "5.11.0") qtwebchannel;
   buildInputs = [ fontconfig libwebp libxml2 libxslt sqlite glib gst_all_1.gstreamer gst_all_1.gst-plugins-base ]
-    ++ optionals (stdenv.isDarwin) (with darwin.apple_sdk.frameworks; [ OpenGL ])
+    ++ optionals (stdenv.isDarwin) (with darwin; with apple_sdk.frameworks; [ cf-private OpenGL ])
     ++ optionals (lib.versionAtLeast qtbase.version "5.11.0") [ hyphen ];
   nativeBuildInputs = [
     bison2 flex gdb gperf perl pkgconfig python2 ruby

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

···
+{ stdenv
+, buildPythonPackage
+, fetchPypi
+, enum34
+, grpc_google_iam_v1
+, google_api_core
+, pytest
+}:
+
+buildPythonPackage rec {
+  pname = "google-cloud-asset";
+  version = "0.1.1";
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "cec2f44a670371e24e6140c454fdac3ed06be0a021042c6756a3284b505335c7";
+  };
+
+  checkInputs = [ pytest ];
+  propagatedBuildInputs = [ enum34 grpc_google_iam_v1 google_api_core ];
+
+  checkPhase = ''
+    pytest tests/unit
+  '';
+
+  meta = with stdenv.lib; {
+    description = "Cloud Asset API API client library";
+    homepage = https://github.com/GoogleCloudPlatform/google-cloud-python;
+    license = licenses.asl20;
+    maintainers = [ maintainers.costrouc ];
+  };
+}

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

···
+{ stdenv
+, buildPythonPackage
+, fetchPypi
+, enum34
+, google_api_core
+, pytest
+}:
+
+buildPythonPackage rec {
+  pname = "google-cloud-automl";
+  version = "0.1.1";
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "793d463f78d22a822196cb3e34b247fbdba07eeae15ceadb911f5ccecd843f87";
+  };
+
+  checkInputs = [ pytest ];
+  propagatedBuildInputs = [ enum34 google_api_core ];
+
+  checkPhase = ''
+    pytest tests/unit
+  '';
+
+  meta = with stdenv.lib; {
+    description = "Cloud AutoML API client library";
+    homepage = https://github.com/GoogleCloudPlatform/google-cloud-python;
+    license = licenses.asl20;
+    maintainers = [ maintainers.costrouc ];
+  };
+}

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

···
+{ stdenv
+, buildPythonPackage
+, fetchPypi
+, google_resumable_media
+, google_api_core
+, google_cloud_core
+, pandas
+, pyarrow
+, pytest
+, mock
+, ipython
+}:
+
+buildPythonPackage rec {
+  pname = "google-cloud-bigquery";
+  version = "1.6.0";
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "d559ba1e05cf6a960e09bb5aab3aeb4d50ad9e08c77a20a17c01c9b2bd8d6cb7";
+  };
+
+  checkInputs = [ pytest mock ipython ];
+  propagatedBuildInputs = [ google_resumable_media google_api_core google_cloud_core pandas pyarrow ];
+
+  checkPhase = ''
+    pytest tests/unit
+  '';
+
+  meta = with stdenv.lib; {
+    description = "Google BigQuery API client library";
+    homepage = https://github.com/GoogleCloudPlatform/google-cloud-python;
+    license = licenses.asl20;
+    maintainers = [ maintainers.costrouc ];
+  };
+}

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

···
+{ stdenv
+, buildPythonPackage
+, fetchPypi
+, google_api_core
+, pytest
+}:
+
+buildPythonPackage rec {
+  pname = "google-cloud-bigquery-datatransfer";
+  version = "0.1.1";
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "f5b5d0de43805fa9ebb620c58e1d27e6d32d2fc8e9a2f954ee170f7a026c8757";
+  };
+
+  checkInputs = [ pytest ];
+  propagatedBuildInputs = [ google_api_core ];
+
+  checkPhase = ''
+    pytest tests/unit
+  '';
+
+  meta = with stdenv.lib; {
+    description = "BigQuery Data Transfer API client library";
+    homepage = https://github.com/GoogleCloudPlatform/google-cloud-python;
+    license = licenses.asl20;
+    maintainers = [ maintainers.costrouc ];
+  };
+}

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

···
+{ stdenv
+, buildPythonPackage
+, fetchPypi
+, grpc_google_iam_v1
+, google_api_core
+, google_cloud_core
+, pytest
+, mock
+}:
+
+buildPythonPackage rec {
+  pname = "google-cloud-bigtable";
+  version = "0.31.0";
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "b6c8572697b5fdc7fcb95d88f87b8c84cea5a7aef2d57d3de0d6a9e2b0e8424f";
+  };
+
+  checkInputs = [ pytest mock ];
+  propagatedBuildInputs = [ grpc_google_iam_v1 google_api_core google_cloud_core ];
+
+  checkPhase = ''
+    pytest tests/unit
+  '';
+
+  meta = with stdenv.lib; {
+    description = "Google Cloud Bigtable API client library";
+    homepage = https://github.com/GoogleCloudPlatform/google-cloud-python;
+    license = licenses.asl20;
+    maintainers = [ maintainers.costrouc ];
+  };
+}

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

···
+{ stdenv
+, buildPythonPackage
+, fetchPypi
+, google_api_core
+, pytest
+}:
+
+buildPythonPackage rec {
+  pname = "google-cloud-container";
+  version = "0.1.1";
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "a89afcb1fe96bc9361c231c223c3bbe19fa3787caeb4697cd5778990e1077270";
+  };
+
+  checkInputs = [ pytest ];
+  propagatedBuildInputs = [ google_api_core ];
+
+  checkPhase = ''
+    pytest tests/unit
+  '';
+
+  meta = with stdenv.lib; {
+    description = "Google Container Engine API client library";
+    homepage = https://github.com/GoogleCloudPlatform/google-cloud-python;
+    license = licenses.asl20;
+    maintainers = [ maintainers.costrouc ];
+  };
+}

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

···
+{ stdenv
+, buildPythonPackage
+, fetchPypi
+, google_api_core
+, pytest
+}:
+
+buildPythonPackage rec {
+  pname = "google-cloud-dataproc";
+  version = "0.2.0";
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "531dbd3e5862df5e67751efdcd89f00d0ded35f3a87a18fd3245e1c365080720";
+  };
+
+  checkInputs = [ pytest ];
+  propagatedBuildInputs = [ google_api_core ];
+
+  checkPhase = ''
+    pytest tests/unit
+  '';
+
+  meta = with stdenv.lib; {
+    description = "Google Cloud Dataproc API client library";
+    homepage = https://github.com/GoogleCloudPlatform/google-cloud-python;
+    license = licenses.asl20;
+    maintainers = [ maintainers.costrouc ];
+  };
+}

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

···
+{ stdenv
+, buildPythonPackage
+, fetchPypi
+, google_api_core
+, google_cloud_core
+, pytest
+, mock
+}:
+
+buildPythonPackage rec {
+  pname = "google-cloud-datastore";
+  version = "1.7.1";
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "03c1a06b0d94ac2f801513c9255bd5fc8773d036f0e59d63ffe1152cfe4320de";
+  };
+
+  checkInputs = [ pytest mock ];
+  propagatedBuildInputs = [ google_api_core google_cloud_core ];
+
+  checkPhase = ''
+    pytest tests/unit
+  '';
+
+  meta = with stdenv.lib; {
+    description = "Google Cloud Datastore API client library";
+    homepage = https://github.com/GoogleCloudPlatform/google-cloud-python;
+    license = licenses.asl20;
+    maintainers = [ maintainers.costrouc ];
+  };
+}

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

···
+{ stdenv
+, buildPythonPackage
+, fetchPypi
+, enum34
+, google_api_core
+, pytest
+}:
+
+buildPythonPackage rec {
+  pname = "google-cloud-dlp";
+  version = "0.9.0";
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "408e5c6820dc53dd589a7bc378d25c2cf5817c448b7c7b1268bc745ecbe04ec3";
+  };
+
+  checkInputs = [ pytest ];
+  propagatedBuildInputs = [ enum34 google_api_core ];
+
+  checkPhase = ''
+    pytest tests/unit
+  '';
+
+  meta = with stdenv.lib; {
+    description = "Cloud Data Loss Prevention (DLP) API API client library";
+    homepage = https://github.com/GoogleCloudPlatform/google-cloud-python;
+    license = licenses.asl20;
+    maintainers = [ maintainers.costrouc ];
+  };
+}

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

···
+{ stdenv
+, buildPythonPackage
+, fetchPypi
+, google_api_core
+, google_cloud_core
+, pytest
+, mock
+}:
+
+buildPythonPackage rec {
+  pname = "google-cloud-dns";
+  version = "0.29.0";
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "f6ea35676c59b6bfd4a2e6aa42670c6ed3505ba46f7117cdc953094e568f404e";
+  };
+
+  checkInputs = [ pytest mock ];
+  propagatedBuildInputs = [ google_api_core google_cloud_core ];
+
+  checkPhase = ''
+    pytest tests/unit
+  '';
+
+  meta = with stdenv.lib; {
+    description = "Google Cloud DNS API client library";
+    homepage = https://github.com/GoogleCloudPlatform/google-cloud-python;
+    license = licenses.asl20;
+    maintainers = [ maintainers.costrouc ];
+  };
+}

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

···
+{ stdenv
+, buildPythonPackage
+, fetchPypi
+, google_cloud_logging
+, pytest
+, mock
+}:
+
+buildPythonPackage rec {
+  pname = "google-cloud-error-reporting";
+  version = "0.30.0";
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "768a5c3ed7a96b60f051717c1138e561493ab0ef4dd4acbcf9e2b1cc2d09e06a";
+  };
+
+  checkInputs = [ pytest mock ];
+  propagatedBuildInputs = [ google_cloud_logging ];
+
+  checkPhase = ''
+    pytest tests/unit
+  '';
+
+  meta = with stdenv.lib; {
+    description = "Stackdriver Error Reporting API client library";
+    homepage = https://github.com/GoogleCloudPlatform/google-cloud-python;
+    license = licenses.asl20;
+    maintainers = [ maintainers.costrouc ];
+  };
+}

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

···
+{ stdenv
+, buildPythonPackage
+, fetchPypi
+, google_api_core
+, google_cloud_core
+, pytest
+}:
+
+buildPythonPackage rec {
+  pname = "google-cloud-firestore";
+  version = "0.30.0";
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "7f990572ace890867bbbc63c9d700c1d2635ba4c799e05f30b6fdca490021243";
+  };
+
+  checkInputs = [ pytest ];
+  propagatedBuildInputs = [ google_api_core google_cloud_core ];
+
+  # tests were not included with release
+  # See issue https://github.com/googleapis/google-cloud-python/issues/6380
+  doCheck = false;
+
+  checkPhase = ''
+    pytest tests/unit
+  '';
+
+  meta = with stdenv.lib; {
+    description = "Google Cloud Firestore API client library";
+    homepage = https://github.com/GoogleCloudPlatform/google-cloud-python;
+    license = licenses.asl20;
+    maintainers = [ maintainers.costrouc ];
+  };
+}

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

···
+{ stdenv
+, buildPythonPackage
+, fetchPypi
+, enum34
+, grpc_google_iam_v1
+, google_api_core
+, pytest
+}:
+
+buildPythonPackage rec {
+  pname = "google-cloud-iot";
+  version = "0.1.0";
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "1502fa6d64f8f0f7c0e34e71c82c5daacc8fd8f78256cfadef5ae06c5efcc3b4";
+  };
+
+  checkInputs = [ pytest ];
+  propagatedBuildInputs = [ enum34 grpc_google_iam_v1 google_api_core ];
+
+  checkPhase = ''
+    pytest tests/unit
+  '';
+
+  meta = with stdenv.lib; {
+    description = "Cloud IoT API API client library";
+    homepage = https://github.com/GoogleCloudPlatform/google-cloud-python;
+    license = licenses.asl20;
+    # maintainers = [ maintainers. ];
+  };
+}

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

···
+{ stdenv
+, buildPythonPackage
+, fetchPypi
+, enum34
+, grpc_google_iam_v1
+, google_api_core
+, pytest
+}:
+
+buildPythonPackage rec {
+  pname = "google-cloud-kms";
+  version = "0.2.0";
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "add648f9185a8724f8632b3a006ee0af4847a5ab4ca085954ff1d00a8cd2d54c";
+  };
+
+  checkInputs = [ pytest ];
+  propagatedBuildInputs = [ enum34 grpc_google_iam_v1 google_api_core ];
+
+  checkPhase = ''
+    pytest tests/unit
+  '';
+
+  meta = with stdenv.lib; {
+    description = "Cloud Key Management Service (KMS) API API client library";
+    homepage = https://github.com/GoogleCloudPlatform/google-cloud-python;
+    license = licenses.asl20;
+    maintainers = [ maintainers.costrouc ];
+  };
+}

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

···
+{ stdenv
+, buildPythonPackage
+, fetchPypi
+, enum34
+, google_api_core
+, pytest
+}:
+
+buildPythonPackage rec {
+  pname = "google-cloud-language";
+  version = "1.1.0";
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "2450e3265df129241cb21badb9d4ce2089d2652581df38e03c14a7ec85679ecb";
+  };
+
+  checkInputs = [ pytest ];
+  propagatedBuildInputs = [ enum34 google_api_core ];
+
+  checkPhase = ''
+    pytest tests/unit
+  '';
+
+  meta = with stdenv.lib; {
+    description = "Google Cloud Natural Language API client library";
+    homepage = https://github.com/GoogleCloudPlatform/google-cloud-python;
+    license = licenses.asl20;
+    maintainers = [ maintainers.costrouc ];
+  };
+}

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

···
+{ stdenv
+, buildPythonPackage
+, fetchPypi
+, google_api_core
+, google_cloud_core
+, pytest
+, mock
+, webapp2
+, django
+, flask
+}:
+
+buildPythonPackage rec {
+  pname = "google-cloud-logging";
+  version = "1.8.0";
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "418ae534a8044ea5fd385fc4958763d76b8f315785d7a61f264c5a04035d02d5";
+  };
+
+  checkInputs = [ pytest mock webapp2 django flask ];
+  propagatedBuildInputs = [ google_api_core google_cloud_core ];
+
+  checkPhase = ''
+    pytest tests/unit
+  '';
+
+  meta = with stdenv.lib; {
+    description = "Stackdriver Logging API client library";
+    homepage = https://github.com/GoogleCloudPlatform/google-cloud-python;
+    license = licenses.asl20;
+    maintainers = [ maintainers.costrouc ];
+  };
+}

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

···
+{ stdenv
+, buildPythonPackage
+, fetchPypi
+, google_api_core
+, pandas
+, pytest
+, mock
+}:
+
+buildPythonPackage rec {
+  pname = "google-cloud-monitoring";
+  version = "0.30.1";
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "6b26d659360306d51b9fb88c5b1eb77bf49967a37b6348ae9568c083e466274d";
+  };
+
+  checkInputs = [ pytest mock ];
+  propagatedBuildInputs = [ google_api_core pandas ];
+
+  checkPhase = ''
+    pytest tests/unit
+  '';
+
+  meta = with stdenv.lib; {
+    description = "Stackdriver Monitoring API client library";
+    homepage = https://github.com/GoogleCloudPlatform/google-cloud-python;
+    license = licenses.asl20;
+    maintainers = [ maintainers.costrouc ];
+  };
+}

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

···
+{ stdenv
+, buildPythonPackage
+, fetchPypi
+, enum34
+, grpc_google_iam_v1
+, google_api_core
+, pytest
+, mock
+}:
+
+buildPythonPackage rec {
+  pname = "google-cloud-pubsub";
+  version = "0.38.0";
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "0b0481fa61faf8143c3cffc9d3fbe757423a200fbddddcf27feb2c49e3c35e58";
+  };
+
+  checkInputs = [ pytest mock ];
+  propagatedBuildInputs = [ enum34 grpc_google_iam_v1 google_api_core ];
+
+  checkPhase = ''
+    pytest tests/unit
+  '';
+
+  meta = with stdenv.lib; {
+    description = "Google Cloud Pub/Sub API client library";
+    homepage = https://github.com/GoogleCloudPlatform/google-cloud-python;
+    license = licenses.asl20;
+    maintainers = [ maintainers.costrouc ];
+  };
+}

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

···
+{ stdenv
+, buildPythonPackage
+, fetchPypi
+, enum34
+, google_api_core
+, pytest
+}:
+
+buildPythonPackage rec {
+  pname = "google-cloud-redis";
+  version = "0.2.0";
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "c0fa00cafbce3e9a0e35fb7f9d754ac70b450b6496c62c20bb3a1f500aeca9e4";
+  };
+
+  checkInputs = [ pytest ];
+  propagatedBuildInputs = [ enum34 google_api_core ];
+
+  # requires old version of google-api-core (override)
+  preBuild = ''
+    sed -i "s/'google-api-core\[grpc\] >= 0.1.0, < 0.2.0dev'/'google-api-core'/g" setup.py
+    sed -i "s/google-api-core\[grpc\]<0.2.0dev,>=0.1.0/google-api-core/g" google_cloud_redis.egg-info/requires.txt
+  '';
+
+  checkPhase = ''
+    pytest tests/unit
+  '';
+
+  meta = with stdenv.lib; {
+    description = "Google Cloud Memorystore for Redis API client library";
+    homepage = https://github.com/GoogleCloudPlatform/google-cloud-python;
+    license = licenses.asl20;
+    maintainers = [ maintainers.costrouc ];
+  };
+}

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

···
+{ stdenv
+, buildPythonPackage
+, fetchPypi
+, google_cloud_core
+, google_api_core
+, pytest
+, mock
+}:
+
+buildPythonPackage rec {
+  pname = "google-cloud-resource-manager";
+  version = "0.28.1";
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "fc29c11dcbe9208261d377185a1ae5331bab43f2a592222a25c8aca9c8031308";
+  };
+
+  checkInputs = [ pytest mock ];
+  propagatedBuildInputs = [ google_cloud_core google_api_core ];
+
+  checkPhase = ''
+    pytest tests/unit
+  '';
+
+  meta = with stdenv.lib; {
+    description = "Google Cloud Resource Manager API client library";
+    homepage = https://github.com/GoogleCloudPlatform/google-cloud-python;
+    license = licenses.asl20;
+    maintainers = [ maintainers.costrouc ];
+  };
+}

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

···
+{ stdenv
+, buildPythonPackage
+, fetchPypi
+, google_api_core
+, google_cloud_core
+, pytest
+, mock
+}:
+
+buildPythonPackage rec {
+  pname = "google-cloud-runtimeconfig";
+  version = "0.28.1";
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "f441fbc22e2d0871ecb390854aa352cf467d2751cbc0dac7578274ead813519e";
+  };
+
+  checkInputs = [ pytest mock ];
+  propagatedBuildInputs = [ google_api_core google_cloud_core ];
+
+  checkPhase = ''
+    pytest tests/unit
+  '';
+
+  meta = with stdenv.lib; {
+    description = "Google Cloud RuntimeConfig API client library";
+    homepage = https://github.com/GoogleCloudPlatform/google-cloud-python;
+    license = licenses.asl20;
+    maintainers = [ maintainers.costrouc ];
+  };
+}

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

···
+{ stdenv
+, buildPythonPackage
+, fetchPypi
+, enum34
+, grpc_google_iam_v1
+, google_api_core
+, pytest
+}:
+
+buildPythonPackage rec {
+  pname = "google-cloud-securitycenter";
+  version = "0.1.0";
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "6ef386ba065a167670ad1b67f15fb7ba9e21ce33579fa6d7fafafd5b970b3e8a";
+  };
+
+  checkInputs = [ pytest ];
+  propagatedBuildInputs = [ enum34 grpc_google_iam_v1 google_api_core ];
+
+  checkPhase = ''
+    pytest tests/unit
+  '';
+
+  meta = with stdenv.lib; {
+    description = "Cloud Security Command Center API API client library";
+    homepage = https://github.com/GoogleCloudPlatform/google-cloud-python;
+    license = licenses.asl20;
+    maintainers = [ maintainers.costrouc ];
+  };
+}

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

···
+{ stdenv
+, buildPythonPackage
+, fetchPypi
+, grpc_google_iam_v1
+, grpcio-gcp
+, google_api_core
+, google_cloud_core
+, pytest
+, mock
+}:
+
+buildPythonPackage rec {
+  pname = "google-cloud-spanner";
+  version = "1.6.0";
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "f7140e1cb43fbf670521112f03822b63d15fbcbd2830c7cfa1b868836e04b6b4";
+  };
+
+  checkInputs = [ pytest mock ];
+  propagatedBuildInputs = [ grpcio-gcp grpc_google_iam_v1 google_api_core google_cloud_core ];
+
+  checkPhase = ''
+    pytest tests/unit
+  '';
+
+  meta = with stdenv.lib; {
+    description = "Cloud Spanner API client library";
+    homepage = https://github.com/GoogleCloudPlatform/google-cloud-python;
+    license = licenses.asl20;
+    maintainers = [ maintainers.costrouc ];
+  };
+}

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

···
   propagatedBuildInputs = [ google_api_core ];
   checkInputs = [ pytest mock ];
 
-  # needs credentials
-  doCheck = false;
+  checkPhase = ''
+    pytest tests/unit
+  '';
 
   meta = with stdenv.lib; {
     description = "Cloud Speech API enables integration of Google speech recognition into applications.";

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

···
+{ stdenv
+, buildPythonPackage
+, fetchPypi
+, google_resumable_media
+, google_api_core
+, google_cloud_core
+, pytest
+, mock
+}:
+
+buildPythonPackage rec {
+  pname = "google-cloud-storage";
+  version = "1.13.0";
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "fc32b9be41a45016ba2387e3ad23e70ccba399d626ef596409316f7cee477956";
+  };
+
+  checkInputs = [ pytest mock ];
+  propagatedBuildInputs = [ google_resumable_media google_api_core google_cloud_core ];
+
+  checkPhase = ''
+   pytest tests/unit
+  '';
+
+  meta = with stdenv.lib; {
+    description = "Google Cloud Storage API client library";
+    homepage = https://github.com/GoogleCloudPlatform/google-cloud-python;
+    license = licenses.asl20;
+    maintainers = [ maintainers.costrouc ];
+  };
+}

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

···
+{ stdenv
+, buildPythonPackage
+, fetchPypi
+, enum34
+, grpc_google_iam_v1
+, google_api_core
+, pytest
+}:
+
+buildPythonPackage rec {
+  pname = "google-cloud-tasks";
+  version = "0.3.0";
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "f874a7aabad225588263c6cbcd4d67455cc682ebb6d9f00bd06c8d2d5673b4db";
+  };
+
+  checkInputs = [ pytest ];
+  propagatedBuildInputs = [ enum34 grpc_google_iam_v1 google_api_core ];
+
+  checkPhase = ''
+    pytest tests/unit
+  '';
+
+  meta = with stdenv.lib; {
+    description = "Cloud Tasks API API client library";
+    homepage = https://github.com/GoogleCloudPlatform/google-cloud-python;
+    license = licenses.asl20;
+    maintainers = [ maintainers.costrouc ];
+  };
+}

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

···
+{ stdenv
+, buildPythonPackage
+, fetchFromGitHub
+, six
+, google_auth
+}:
+
+buildPythonPackage rec {
+  pname = "google-cloud-testutils";
+  version = "unstable-36ffa923c7037e8b4fdcaa76272cb6267e908a9d";
+
+  # google-cloud-testutils is not "really"
+  # released as a python package
+  # but it is required for google-cloud-* tests
+  # so why not package it as a module
+  src = fetchFromGitHub {
+    owner = "googleapis";
+    repo = "google-cloud-python";
+    rev = "36ffa923c7037e8b4fdcaa76272cb6267e908a9d";
+    sha256 = "1fvcnssmpgf4lfr7l9h7cz984rbc5mfr1j1br12japcib5biwzjy";
+  };
+
+  propagatedBuildInputs = [ six google_auth ];
+
+  postPatch = ''
+    cd test_utils
+  '';
+
+  meta = with stdenv.lib; {
+    description = "System test utilities for google-cloud-python";
+    homepage = https://github.com/GoogleCloudPlatform/google-cloud-python;
+    license = licenses.asl20;
+    maintainers = [ maintainers.costrouc ];
+  };
+}

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

···
+{ stdenv
+, buildPythonPackage
+, fetchPypi
+, google_api_core
+, pytest
+}:
+
+buildPythonPackage rec {
+  pname = "google-cloud-texttospeech";
+  version = "0.2.0";
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "6064bc6e2761694b708878ff3d5902c6ce5eb44a770a921e7a99caf6c2533ae3";
+  };
+
+  checkInputs = [ pytest ];
+  propagatedBuildInputs = [ google_api_core ];
+
+  checkPhase = ''
+    pytest tests/unit
+  '';
+
+  meta = with stdenv.lib; {
+    description = "Google Cloud Text-to-Speech API client library";
+    homepage = https://github.com/GoogleCloudPlatform/google-cloud-python;
+    license = licenses.asl20;
+    maintainers = [ maintainers.costrouc ];
+  };
+}

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

···
+{ stdenv
+, buildPythonPackage
+, fetchPypi
+, google_api_core
+, google_cloud_core
+, pytest
+, mock
+}:
+
+buildPythonPackage rec {
+  pname = "google-cloud-trace";
+  version = "0.19.0";
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "2cb774498e90143a9565dd50e2814b6b0292242a53b8804a1a529989e18b7461";
+  };
+
+  checkInputs = [ pytest mock ];
+  propagatedBuildInputs = [ google_api_core google_cloud_core ];
+
+  checkPhase = ''
+    pytest tests/unit
+  '';
+
+  meta = with stdenv.lib; {
+    description = "Stackdriver Trace API client library";
+    homepage = https://github.com/GoogleCloudPlatform/google-cloud-python;
+    license = licenses.asl20;
+    maintainers = [ maintainers.costrouc ];
+  };
+}

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

···
+{ stdenv
+, buildPythonPackage
+, fetchPypi
+, google_api_core
+, google_cloud_core
+, pytest
+, mock
+}:
+
+buildPythonPackage rec {
+  pname = "google-cloud-translate";
+  version = "1.3.1";
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "4420f5b320145bf097ca9a12b18ec27c067886e2832d181f268c46c3bcb0d2e4";
+  };
+
+  checkInputs = [ pytest mock ];
+  propagatedBuildInputs = [ google_api_core google_cloud_core ];
+
+  checkPhase = ''
+    pytest tests/unit
+  '';
+
+  meta = with stdenv.lib; {
+    description = "Google Cloud Translation API client library";
+    homepage = https://github.com/GoogleCloudPlatform/google-cloud-python;
+    license = licenses.asl20;
+    maintainers = [ maintainers.costrouc ];
+  };
+}

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

···
+{ stdenv
+, buildPythonPackage
+, fetchPypi
+, google_api_core
+, pytest
+}:
+
+buildPythonPackage rec {
+  pname = "google-cloud-videointelligence";
+  version = "1.5.0";
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "bd0abc18070520fd5757b15356e8483149e1caebbe43019257ccb2c43cddbbbe";
+  };
+
+  checkInputs = [ pytest ];
+  propagatedBuildInputs = [ google_api_core ];
+
+  checkPhase = ''
+    pytest tests/unit
+  '';
+
+  meta = with stdenv.lib; {
+    description = "Google Cloud Video Intelligence API client library";
+    homepage = https://github.com/GoogleCloudPlatform/google-cloud-python;
+    license = licenses.asl20;
+    maintainers = [ maintainers.costrouc ];
+  };
+}

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

···
+{ stdenv
+, buildPythonPackage
+, fetchPypi
+, enum34
+, google_api_core
+, pytest
+, mock
+}:
+
+buildPythonPackage rec {
+  pname = "google-cloud-vision";
+  version = "0.34.0";
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "50392b2c68e40dbf725c531ba4d325bd910da6441a472ed0a3fadfd0ab8548f7";
+  };
+
+  checkInputs = [ pytest mock ];
+  propagatedBuildInputs = [ enum34 google_api_core ];
+
+  checkPhase = ''
+    pytest tests/unit
+  '';
+
+  meta = with stdenv.lib; {
+    description = "Cloud Vision API API client library";
+    homepage = https://github.com/GoogleCloudPlatform/google-cloud-python;
+    license = licenses.asl20;
+    maintainers = [ maintainers.costrouc ];
+  };
+}

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

···
+{ stdenv
+, buildPythonPackage
+, fetchPypi
+, google_api_core
+, pytest
+}:
+
+buildPythonPackage rec {
+  pname = "google-cloud-websecurityscanner";
+  version = "0.1.0";
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "d41a9e1a093862aa1b181fa7fdc2a94e185eb4a8f290dbdb928bc9ebd253a95f";
+  };
+
+  checkInputs = [ pytest ];
+  propagatedBuildInputs = [ google_api_core ];
+
+  checkPhase = ''
+    pytest tests/unit
+  '';
+
+  meta = with stdenv.lib; {
+    description = "Google Cloud Web Security Scanner API client library";
+    homepage = https://github.com/GoogleCloudPlatform/google-cloud-python;
+    license = licenses.asl20;
+    maintainers = [ maintainers.costrouc ];
+  };
+}

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

···
+{ stdenv
+, buildPythonPackage
+, fetchPypi
+, six
+, requests
+, pytest
+, mock
+}:
+
+buildPythonPackage rec {
+  pname = "google-resumable-media";
+  version = "0.3.1";
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "97de518f8166d442cc0b61fab308bcd319dbb970981e667ec8ded44f5ce49836";
+  };
+
+  checkInputs = [ pytest mock ];
+  propagatedBuildInputs = [ six requests ];
+
+  checkPhase = ''
+    py.test tests/unit
+  '';
+
+  meta = with stdenv.lib; {
+    description = "Utilities for Google Media Downloads and Resumable Uploads";
+    homepage = https://github.com/GoogleCloudPlatform/google-resumable-media-python;
+    license = licenses.asl20;
+    maintainers = [ maintainers.costrouc ];
+  };
+}

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

···
+{ stdenv
+, buildPythonPackage
+, fetchPypi
+, grpcio
+, googleapis_common_protos
+}:
+
+buildPythonPackage rec {
+  pname = "grpc-google-iam-v1";
+  version = "0.11.4";
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "5009e831dcec22f3ff00e89405249d6a838d1449a46ac8224907aa5b0e0b1aec";
+  };
+
+  propagatedBuildInputs = [ grpcio googleapis_common_protos ];
+
+  meta = with stdenv.lib; {
+    description = "GRPC library for the google-iam-v1 service";
+    homepage = https://github.com/googleapis/googleapis;
+    license = licenses.asl20;
+    maintainers = [ maintainers.costrouc ];
+  };
+}

pkgs/development/python-modules/grpcio-gcp/default.nix

···
+{ stdenv
+, buildPythonPackage
+, fetchPypi
+, grpcio
+}:
+
+buildPythonPackage rec {
+  pname = "grpcio-gcp";
+  version = "0.2.2";
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "e292605effc7da39b7a8734c719afb12ec4b5362add3528d8afad3aa3aa9057c";
+  };
+
+  propagatedBuildInputs = [ grpcio ];
+
+  meta = with stdenv.lib; {
+    description = "gRPC extensions for Google Cloud Platform";
+    homepage = https://grpc.io;
+    license = licenses.asl20;
+    maintainers = [ maintainers.costrouc ];
+  };
+}

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

···
-{ stdenv, lib, buildPythonPackage, fetchPypi, isPyPy, libgit2, six, cffi }:
+{ stdenv, lib, buildPythonPackage, fetchPypi, fetchpatch, isPyPy, libgit2_0_27, six, cffi }:
 
 buildPythonPackage rec {
   pname = "pygit2";
-  version = "0.26.4";
+  version = "0.27.2";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "a8a0ecce4aadac2675afa5bcda0f698bfe39ec61ac1e15b9264704d1b41bb390";
+    sha256 = "0d9bgxd6ch5jxz0j5cmx7c4kw933g8pgm2zxf3id1a6w9g2r7hpw";
   };
 
   preConfigure = lib.optionalString stdenv.isDarwin ''
-    export DYLD_LIBRARY_PATH="${libgit2}/lib"
+    export DYLD_LIBRARY_PATH="${libgit2_0_27}/lib"
   '';
 
-  propagatedBuildInputs = [ libgit2 six ] ++ lib.optional (!isPyPy) cffi;
+  patches = [ (fetchpatch {
+    name = "dont-require-old-pycparser"; # https://github.com/libgit2/pygit2/issues/819
+    url = https://github.com/libgit2/pygit2/commit/1eaba181577de206d3d43ec7886d0353fc0c9f2a.patch;
+    sha256 = "18x1fpmywhjjr4lvakwmy34zpxfqi8pqqj48g1wcib39lh3s7l4f";
+  }) ];
+
+  propagatedBuildInputs = [ libgit2_0_27 six ] ++ lib.optional (!isPyPy) cffi;
 
   preCheck = ''
     # disable tests that require networking

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

···
 
 buildPythonPackage rec {
   pname = "simanneal";
-  version = "0.4.1";
+  version = "0.4.2";
 
   src = fetchFromGitHub {
     owner = "perrygeo";
     repo = "simanneal";
     rev = version;
-    sha256 = "12499wvf7ii7cy8z2f1d472p7q9napg1lj0h9xx8l1mbr1hjlp3q";
+    sha256 = "0p75da4nbk6iy16aahl0ilqg605jrr6aa1pzfyd9hc7ak2vs6840";
   };
 
   checkInputs = [ pytest ];

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

···
+{ stdenv
+, buildPythonPackage
+, fetchPypi
+, webob
+, six
+, jinja2
+}:
+
+buildPythonPackage rec {
+  pname = "webapp2";
+  version = "2.5.2";
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "997db622a266bd64eb7fcc9cfe823efb69277544aa92064030c16acbfb2733a5";
+  };
+
+  # # error in tests when running with python 3+
+  doCheck = false;
+
+  propagatedBuildInputs = [ webob six ];
+
+  meta = with stdenv.lib; {
+    description = "Taking Google App Engine's webapp to the next level";
+    homepage = http://webapp-improved.appspot.com;
+    license = licenses.asl20;
+    maintainers = [ maintainers.costrouc ];
+  };
+}

pkgs/development/tools/kythe/default.nix

···
-{ stdenv, binutils , fetchurl, glibc }:
+{ stdenv, binutils , fetchurl, glibc, ncurses5 }:
 
 stdenv.mkDerivation rec {
   version = "0.0.28";
···
     cd tools
     for exe in http_server \
                 kythe read_entries triples verifier \
-                write_entries write_tables; do
+                write_entries write_tables entrystream; do
       echo "Patching:" $exe
       patchelf --interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" $exe
-      patchelf --set-rpath "${stdenv.cc.cc.lib}/lib64" $exe
+      patchelf --set-rpath "${stdenv.cc.cc.lib}/lib64:${ncurses5}/lib" $exe
     done
     cd ../
     cp -R ./ $out
+    ln -s $out/tools $out/bin
   '';
 
   meta = with stdenv.lib; {

pkgs/development/tools/misc/gede/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "gede-${version}";
-  version = "2.10.9";
+  version = "2.12.3";
 
   src = fetchurl {
     url = "http://gede.acidron.com/uploads/source/${name}.tar.xz";
-    sha256 = "0av9v3r6x6anjjm4hzn8wxnvrqc8zp1g7570m5ndg7cgc3sy3bg6";
+    sha256 = "041wvby19dlcbb7x3yn2mbcfkrn0pkyjpgm40ngsks63kqzmkpdp";
   };
 
   nativeBuildInputs = [ qmake makeWrapper python ];

pkgs/games/openarena/default.nix

···
-{ fetchurl, makeWrapper, patchelf, pkgs, stdenv, SDL, libglvnd, libogg, libvorbis, curl }:
+{ fetchurl, makeWrapper, patchelf, pkgs, stdenv, SDL, libglvnd, libogg, libvorbis, curl, openal }:
 
 stdenv.mkDerivation rec {
   name = "openarena-${version}";
···
   installPhase = let
     gameDir = "$out/openarena-$version";
     interpreter = "$(< \"$NIX_CC/nix-support/dynamic-linker\")";
-    libPath = stdenv.lib.makeLibraryPath [ SDL libglvnd libogg libvorbis curl ];
+    libPath = stdenv.lib.makeLibraryPath [ SDL libglvnd libogg libvorbis curl openal ];
   in ''
     mkdir -pv $out/bin
     cd $out

pkgs/os-specific/linux/evdi/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "evdi-${version}";
-  version = "1.5.0.2";
+  version = "1.5.1";
 
   src = fetchFromGitHub {
     owner = "DisplayLink";
     repo = "evdi";
     rev = "v${version}";
-    sha256 = "1wjk023lpjxnspfl34c6rzkrixahfdzdkmc3hnmrdw12s3i6ca5x";
+    sha256 = "0jy0ia5fsx54d2wv4d2jqnc8rc5x16781a3bcb857apc47zr387h";
   };
 
   nativeBuildInputs = kernel.moduleBuildDependencies;
···
   meta = with stdenv.lib; {
     description = "Extensible Virtual Display Interface";
     platforms = platforms.linux;
-    license = licenses.gpl2;
-    homepage = http://www.displaylink.com/;
-    broken = versionOlder kernel.version "4.9" || versionAtLeast kernel.version "4.15" || stdenv.isAarch64;
+    license = with licenses; [ lgpl21 gpl2 ];
+    homepage = https://www.displaylink.com/;
+    broken = versionOlder kernel.version "4.9" || versionAtLeast kernel.version "4.18" || stdenv.isAarch64;
   };
 }

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

···
 with stdenv.lib;
 
 buildLinux (args // rec {
-  version = "4.14.81";
+  version = "4.14.82";
 
   # modDirVersion needs to be x.y.z, will automatically add .0 if needed
   modDirVersion = if (modDirVersionArg == null) then concatStrings (intersperse "." (take 3 (splitString "." "${version}.0"))) else modDirVersionArg;
···
 
   src = fetchurl {
     url = "mirror://kernel/linux/kernel/v4.x/linux-${version}.tar.xz";
-    sha256 = "1pjvwyhag2i8i5kns8836ifpk93ssvp35m4rfxhz0kl4ag8dydjb";
+    sha256 = "1b8x77kf3q7nf2h3s9vnn0hzi45srxxin7f9rvg70vd7yvka5457";
   };
 } // (args.argsOverride or {}))

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

···
 with stdenv.lib;
 
 buildLinux (args // rec {
-  version = "4.18.19";
+  version = "4.18.20";
 
   # modDirVersion needs to be x.y.z, will automatically add .0 if needed
   modDirVersion = if (modDirVersionArg == null) then concatStrings (intersperse "." (take 3 (splitString "." "${version}.0"))) else modDirVersionArg;
···
 
   src = fetchurl {
     url = "mirror://kernel/linux/kernel/v4.x/linux-${version}.tar.xz";
-    sha256 = "1g9iasj17i6z5494azsbr4pji7qj27f1fasrx36fbxy4rp1w8rkw";
+    sha256 = "0lzn2w8zagqk3sp6jsp155xggm1c277xjh8m0nvddvdp1yg33b38";
   };
 } // (args.argsOverride or {}))

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

···
 with stdenv.lib;
 
 buildLinux (args // rec {
-  version = "4.19.2";
+  version = "4.19.3";
 
   # modDirVersion needs to be x.y.z, will automatically add .0 if needed
   modDirVersion = if (modDirVersionArg == null) then concatStrings (intersperse "." (take 3 (splitString "." "${version}.0"))) else modDirVersionArg;
···
 
   src = fetchurl {
     url = "mirror://kernel/linux/kernel/v4.x/linux-${version}.tar.xz";
-    sha256 = "0wyzy8i2lfhz2rf9ilygl2jgz6iyspv2amx2fzm85mwv060py361";
+    sha256 = "0834k2lsflp6mgxv1vs1gr4fykg5z0hd4sbbrw3z7zfhsh95fg0y";
   };
 } // (args.argsOverride or {}))

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

···
 { stdenv, buildPackages, fetchurl, perl, buildLinux, ... } @ args:
 
 buildLinux (args // rec {
-  version = "4.4.163";
+  version = "4.4.164";
   extraMeta.branch = "4.4";
 
   src = fetchurl {
     url = "mirror://kernel/linux/kernel/v4.x/linux-${version}.tar.xz";
-    sha256 = "1x1fixnz41q6pq1cms9z48mrac984r675m94fdm08m8ajqxddcv1";
+    sha256 = "041w65dxsdcdpf7isis2r4xabfm9pbhfgxxx7n9d1nv7grss3d4v";
   };
 } // (args.argsOverride or {}))

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

···
 { stdenv, buildPackages, fetchurl, perl, buildLinux, ... } @ args:
 
 buildLinux (args // rec {
-  version = "4.9.137";
+  version = "4.9.138";
   extraMeta.branch = "4.9";
 
   src = fetchurl {
     url = "mirror://kernel/linux/kernel/v4.x/linux-${version}.tar.xz";
-    sha256 = "1295x8a8k8bdanrpsalnaaq00mk3fl91sr14061lrgwlj0m53ckd";
+    sha256 = "1dr1mf7i1mwy780048gkhvy283j8331xwgrs2x5qal0xc1114c4j";
   };
 } // (args.argsOverride or {}))

pkgs/servers/jackett/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "jackett-${version}";
-  version = "0.10.434";
+  version = "0.10.446";
 
   src = fetchurl {
     url = "https://github.com/Jackett/Jackett/releases/download/v${version}/Jackett.Binaries.Mono.tar.gz";
-    sha256 = "1vnkppmv7mw2p9bjcfmfxg66g02dq0020ad4z07gbp4dvixpzsnm";
+    sha256 = "1vmgywklax5br3pynjp5b74l2mkmhk3njiccjrl0l7j8ikyar1fw";
   };
 
   buildInputs = [ makeWrapper ];

pkgs/servers/uwsgi/default.nix

···
-{ stdenv, lib, fetchurl, pkgconfig, jansson
+{ stdenv, lib, fetchurl, pkgconfig, jansson, pcre
 # plugins: list of strings, eg. [ "python2" "python3" ]
 , plugins
 , pam, withPAM ? false
···
 
   nativeBuildInputs = [ python3 pkgconfig ];
 
-  buildInputs =  [ jansson ]
+  buildInputs =  [ jansson pcre ]
               ++ lib.optional withPAM pam
               ++ lib.optional withSystemd systemd
               ++ lib.concatMap (x: x.inputs) needed
···
   NIX_CFLAGS_LINK = [ "-lsystemd" ] ++ lib.concatMap (x: x.NIX_CFLAGS_LINK or []) needed;
 
   meta = with stdenv.lib; {
-    homepage = http://uwsgi-docs.readthedocs.org/en/latest/;
+    homepage = https://uwsgi-docs.readthedocs.org/en/latest/;
     description = "A fast, self-healing and developer/sysadmin-friendly application container server coded in pure C";
     license = licenses.gpl2;
     maintainers = with maintainers; [ abbradar schneefux ];

pkgs/stdenv/generic/make-derivation.nix

···
           # propagated dependencies here as well.
           disallowedReferences = (attrs.disallowedReferences or [])
           ++ (lib.subtractLists
-              (lib.concatLists ( (lib.elemAt propagatedDependencies 1) ++
+               (lib.concatLists ((lib.elemAt propagatedDependencies 0) ++
+                                 (lib.elemAt propagatedDependencies 1) ++
                                  (lib.elemAt dependencies 1) ++
                                  (lib.elemAt propagatedDependencies 2) ++
                                  (lib.elemAt dependencies 2) ) )
-              (lib.concatLists ( (lib.elemAt propagatedDependencies 0) ++
-                                 (lib.elemAt dependencies 0) ) ) );
+               (lib.concatLists ((lib.elemAt dependencies 0)) ) );
         } // lib.optionalAttrs (stdenv.hostPlatform != stdenv.buildPlatform) {
           cmakeFlags =
             (/**/ if lib.isString cmakeFlags then [cmakeFlags]

pkgs/test/nixos-functions/default.nix

···
  */
 { pkgs, lib, stdenv, ... }:
 
-lib.optionalAttrs stdenv.hostPlatform.isLinux (
+let
+  dummyVersioning = {
+    revision = "test";
+    versionSuffix = "test";
+    label = "test";
+  };
+in lib.optionalAttrs stdenv.hostPlatform.isLinux (
   pkgs.recurseIntoAttrs {
 
     nixos-test = (pkgs.nixos {
+      system.nixos = dummyVersioning;
       boot.loader.grub.enable = false;
       fileSystems."/".device = "/dev/null";
     }).toplevel;
···
     nixosTest-test = pkgs.nixosTest ({ lib, pkgs, ... }: {
       name = "nixosTest-test";
       machine = { pkgs, ... }: {
+        system.nixos = dummyVersioning;
         environment.systemPackages = [ pkgs.hello ];
       };
       testScript = ''

pkgs/tools/admin/lego/default.nix

···
 
 buildGoPackage rec {
   name = "lego-${version}";
-  version = "1.0.1";
+  version = "1.2.1";
   rev = "v${version}";
 
   src = fetchFromGitHub {
     inherit rev;
     owner = "xenolf";
     repo = "lego";
-    sha256 = "1l9winhqwid8ac8il303qkhsn0v5h7zhlklviszfi1rjal38ipiz";
+    sha256 = "1b2cv78v54afflz3gfyidkwzq7r2h5j45rmz0ybps03pr0hs4gk3";
   };
 
   goPackagePath = "github.com/xenolf/lego";

pkgs/tools/graphics/oxipng/default.nix

···
 { stdenv, fetchFromGitHub, rustPlatform }:
 
 rustPlatform.buildRustPackage rec {
-  version = "2.1.0";
+  version = "2.1.6";
   name = "oxipng-${version}";
 
   src = fetchFromGitHub {
     owner = "shssoichiro";
     repo = "oxipng";
     rev = "v${version}";
-    sha256 = "13rzkfb025y4i9dj66fgc74whgs90gyw861dccsj16cpfl6kh5z0";
+    sha256 = "0n3v2dxybfkf07hb4p2hbhhkwx907b85wzj8wa4whwil89igyrdm";
   };
 
-  cargoSha256 = "0l6ad8rnifd5hkv6x2cr0frdddsfwm1xd1v56imlglsjkgz56cva";
+  cargoSha256 = "1ycacwhwbn27i81jpp55m1446b9a50knlqv0kzkjcv8yf27213y9";
 
   meta = with stdenv.lib; {
     homepage = https://github.com/shssoichiro/oxipng;
-    description = "A lossless PNG compression optimizer";
+    description = "A multithreaded lossless PNG compression optimizer";
     license = licenses.mit;
     maintainers = with maintainers; [ dywedir ];
     platforms = platforms.all;
 
-    # macro is_arm_feature_detected! is unstable
+    # Needs newer/unstable rust: error[E0658]: macro is_arm_feature_detected! is unstable
     broken = stdenv.isAarch64;
   };
 }

pkgs/tools/misc/blsd/default.nix

···
 
   goDeps = ./deps.nix;
 
-  nativeBuildInputs = [ pkgconfig libgit2 ];
+  nativeBuildInputs = [ pkgconfig ];
+  buildInputs = [ libgit2 ];
 
   meta = with stdenv.lib; {
     homepage = https://github.com/junegunn/blsd;

pkgs/tools/misc/dvtm/default.nix

···
-{ stdenv, fetchurl, ncurses, customConfig ? null }:
-
-stdenv.mkDerivation rec {
-
+{callPackage, fetchurl}:
+callPackage ./dvtm.nix rec {
   name = "dvtm-0.15";
 
   src = fetchurl {
-    url = "${meta.homepage}/${name}.tar.gz";
+    url = "http://www.brain-dump.org/projects/dvtm/${name}.tar.gz";
     sha256 = "0475w514b7i3gxk6khy8pfj2gx9l7lv2pwacmq92zn1abv01a84g";
   };
 
···
       sha256 = "1cby8x3ckvhzqa8yxlfrwzgm8wk7yz84kr9psdjr7xwpnca1cqrd";
     })
   ];
-
-  CFLAGS = stdenv.lib.optionalString stdenv.isDarwin "-D_DARWIN_C_SOURCE";
-
-  postPatch = stdenv.lib.optionalString (customConfig != null) ''
-    cp ${builtins.toFile "config.h" customConfig} ./config.h
-  '';
-
-  buildInputs = [ ncurses ];
-
-  prePatch = ''
-    substituteInPlace Makefile \
-      --replace /usr/share/terminfo $out/share/terminfo
-  '';
-
-  installPhase = ''
-    make PREFIX=$out install
-  '';
-
-  meta = with stdenv.lib; {
-    description = "Dynamic virtual terminal manager";
-    homepage = http://www.brain-dump.org/projects/dvtm;
-    license = licenses.mit;
-    maintainers = [ maintainers.vrthra ];
-    platforms = platforms.unix;
-  };
 }
+    

pkgs/tools/misc/dvtm/dvtm.nix

···
+{ stdenv, ncurses, customConfig ? null, name, src, patches ? [] }:
+stdenv.mkDerivation rec {
+
+  inherit name src patches;
+
+  CFLAGS = stdenv.lib.optionalString stdenv.isDarwin "-D_DARWIN_C_SOURCE";
+
+  postPatch = stdenv.lib.optionalString (customConfig != null) ''
+    cp ${builtins.toFile "config.h" customConfig} ./config.h
+  '';
+
+  buildInputs = [ ncurses ];
+
+  prePatch = ''
+    substituteInPlace Makefile \
+      --replace /usr/share/terminfo $out/share/terminfo
+  '';
+
+  installPhase = ''
+    make PREFIX=$out install
+  '';
+
+  meta = with stdenv.lib; {
+    description = "Dynamic virtual terminal manager";
+    homepage = http://www.brain-dump.org/projects/dvtm;
+    license = licenses.mit;
+    maintainers = [ maintainers.vrthra ];
+    platforms = platforms.unix;
+  };
+}

pkgs/tools/misc/dvtm/unstable.nix

···
+{callPackage, fetchFromGitHub, fetchpatch}:
+callPackage ./dvtm.nix {
+  name = "dvtm-unstable-2018-03-31";
+
+  src = fetchFromGitHub {
+    owner = "martanne";
+    repo = "dvtm";
+    rev = "311a8c0c28296f8f87fb63349e0f3254c7481e14";
+    sha256 = "0pyxjkaxh8n97kccnmd3p98vi9h8mcfy5lswzqiplsxmxxmlbpx2";
+  };
+
+  patches = [
+    # https://github.com/martanne/dvtm/pull/69
+    # Use self-pipe instead of signal blocking fixes issues on darwin.
+    (fetchpatch {
+      name = "use-self-pipe-fix-darwin";
+      url = "https://github.com/martanne/dvtm/commit/1f1ed664d64603f3f1ce1388571227dc723901b2.patch";
+      sha256 = "14j3kks7b1v6qq12442v1da3h7khp02rp0vi0qrz0rfgkg1zilpb";
+    })
+
+    # https://github.com/martanne/dvtm/pull/86
+    # Fix buffer corruption when title is updated
+    (fetchpatch {
+      name = "fix-buffer-corruption-on-title-update";
+      url = "https://github.com/martanne/dvtm/commit/be6c3f8f615daeab214d484e6fff22e19631a0d1.patch";
+      sha256 = "1wdrl3sg815lhs22fwbc4w5dn4ifpdgl7v1kqfnhg752av4im7h7";
+    })
+  ];
+}

pkgs/tools/misc/fpart/default.nix

···
-{ stdenv, fetchurl }:
+{ stdenv, fetchFromGitHub, autoreconfHook }:
 
 stdenv.mkDerivation rec {
   name = "fpart-${version}";
-  version = "1.0.0";
+  version = "1.1.0";
 
-  src = fetchurl {
-    url = "http://contribs.martymac.org/fpart/${name}.tar.gz";
-    sha256 = "1p0ajmry18lcg82znfp8nxs4w3izic775l7df08hywlq4vfa66pg";
+  src = fetchFromGitHub {
+    owner = "martymac";
+    repo = "fpart";
+    rev = name;
+    sha256 = "0h3mqc1xj5j2z8s8g3pvvpbjs6x74dj8niyh3p2ymla35kbzskf4";
   };
+
+  nativeBuildInputs = [ autoreconfHook ];
 
   postInstall = ''
     sed "s|^FPART_BIN=.*|FPART_BIN=\"$out/bin/fpart\"|" \

pkgs/tools/misc/mdbtools/default.nix

···
-{ stdenv, fetchurl, glib, readline, bison, flex, pkgconfig }:
+{ stdenv, fetchFromGitHub, glib, readline
+, bison, flex, pkgconfig, autoreconfHook
+, txt2man, which }:
 
-stdenv.mkDerivation {
-  name = "mdbtools-0.6pre1";
+let version = "0.7.1";
+in stdenv.mkDerivation {
+  name = "mdbtools-${version}";
 
-  src = fetchurl {
-    url = mirror://sourceforge/mdbtools/mdbtools-0.6pre1.tar.gz;
-    sha256 = "1lz33lmqifjszad7rl1r7rpxbziprrm5rkb27wmswyl5v98dqsbi";
+  src = fetchFromGitHub {
+    owner = "brianb";
+    repo = "mdbtools";
+    rev = version;
+    sha256 = "0gwcpp9y09xhs21g7my2fs8ncb8i6ahlyixcx8jd3q97jbzj441l";
   };
 
-  nativeBuildInputs = [ pkgconfig ];
-  buildInputs = [glib readline bison flex];
+  nativeBuildInputs = [ pkgconfig bison flex autoreconfHook txt2man which ];
+  buildInputs = [ glib readline ];
 
   preConfigure = ''
     sed -e 's@static \(GHashTable [*]mdb_backends;\)@\1@' -i src/libmdb/backend.c

pkgs/tools/misc/mdbtools/git.nix

···
-{ stdenv, fetchgit, glib, readline, bison, flex, pkgconfig,
-  libiconv, autoreconfHook, which, txt2man, gnome-doc-utils, scrollkeeper }:
-
-stdenv.mkDerivation {
-  name = "mdbtools-git-2014-07-25";
-
-  src = fetchgit {
-    url = "http://github.com/brianb/mdbtools.git";
-    rev = "9ab40e83e6789015c965c92bdb62f92f8cdd0dbd";
-    sha256 = "0hlf5lk86xm0bpdlpk4a1zyfvbim76dhvmybxga2p7mbb1jc825l";
-  };
-
-  nativeBuildInputs = [ pkgconfig ];
-  buildInputs = [
-    glib readline bison flex autoreconfHook which txt2man
-    gnome-doc-utils scrollkeeper libiconv
-  ];
-
-  preAutoreconf = ''
-    sed -e '/ENABLE_GTK_DOC/aAM_CONDITIONAL(HAVE_GNOME_DOC_UTILS, test x$enable_gtk_doc = xyes)' \
-        -e  '/ENABLE_GTK_DOC/aAM_CONDITIONAL(ENABLE_SK, test x$enable_scrollkeeper = xyes)' \
-        -i configure.ac
-  '';
-
-  preConfigure = ''
-    sed -e 's@static \(GHashTable [*]mdb_backends;\)@\1@' -i src/libmdb/backend.c
-  '';
-
-  meta = with stdenv.lib; {
-    description = ".mdb (MS Access) format tools";
-    homepage = http://mdbtools.sourceforge.net;
-    platforms = platforms.linux;
-    license = with licenses; [ gpl2 lgpl2 ];
-  };
-}

pkgs/tools/misc/miniserve/default.nix

···
+{ stdenv, rustPlatform, fetchFromGitHub, cmake, pkgconfig, zlib }:
+
+rustPlatform.buildRustPackage rec {
+  name    = "miniserve-${version}";
+  version = "0.2.1";
+
+  src = fetchFromGitHub {
+    owner  = "svenstaro";
+    repo   = "miniserve";
+    rev    = "v${version}";
+    sha256 = "1g8ggqs4fyscb1r98qj22f61jgkqnr4vdyps0drrvydl9lafdmpl";
+  };
+
+  cargoSha256 = "18wyr0q5pkxds5hrl4g3mqmk46mr0nvs0id94aiw87729ly4vi8c";
+
+  nativeBuildInputs = [ cmake pkgconfig zlib ];
+
+  meta = with stdenv.lib; {
+    description = "For when you really just want to serve some files over HTTP right now!";
+    homepage    = https://github.com/svenstaro/miniserve;
+    license     = with licenses; [ mit ];
+    maintainers = with maintainers; [ nequissimus ];
+    platforms   = platforms.linux;
+  };
+}

pkgs/tools/networking/wireguard-tools/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "wireguard-tools-${version}";
-  version = "0.0.20181018";
+  version = "0.0.20181119";
 
   src = fetchzip {
     url = "https://git.zx2c4.com/WireGuard/snapshot/WireGuard-${version}.tar.xz";
-    sha256 = "0vrr0f89nrpwnyia6kqvrjkxwivrnvjnbavmx2nxlrb3sz23481y";
+    sha256 = "1cxws2h64xvg6idb6jb6rdvn9wgmhdvq8s2lzqjbmds7sj6n09wa";
   };
 
   sourceRoot = "source/src/tools";

pkgs/tools/security/duo-unix/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "duo-unix-${version}";
-  version = "1.10.5";
+  version = "1.11.0";
 
   src = fetchurl {
     url    = "https://dl.duosecurity.com/duo_unix-${version}.tar.gz";
-    sha256 = "1h88gwvbh8vwwga7d65iwa9qrmyx23wh5m0rmlv8qbx4fyj7q1f9";
+    sha256 = "1i3dx7nim7xwlrjzcs9aqfyp87fangxqvhhpr16vpqklkz2zwmw4";
   };
 
   buildInputs = [ pam openssl zlib ];

pkgs/tools/text/xsv/default.nix

···
-{ stdenv, fetchFromGitHub, rustPlatform }:
+{ stdenv, fetchFromGitHub, rustPlatform, Security }:
 
 rustPlatform.buildRustPackage rec {
   name = "xsv-${version}";
···
   };
 
   cargoSha256 = "1qk5wkjm3d4dz5fldlq7rjlm602v0l04hxrbar2j6vhcz9w2r4n6";
+
+  buildInputs = stdenv.lib.optional stdenv.isDarwin Security;
 
   meta = with stdenv.lib; {
     description = "A fast CSV toolkit written in Rust";

pkgs/tools/virtualization/mininet/default.nix

···
+{ stdenv, lib, fetchFromGitHub
+, which
+, python
+, help2man
+}:
+
+let
+  pyEnv = python.withPackages(ps: [ ps.setuptools ]);
+in
+stdenv.mkDerivation rec {
+  name = "mininet-${version}";
+  version = "2.3.0d4";
+
+  outputs = [ "out" "py" ];
+
+  src = fetchFromGitHub {
+    owner = "mininet";
+    repo = "mininet";
+    rev = version;
+    sha256 = "02hsqa7r5ykj8m1ycl32xwn1agjrw78wkq87xif0dl2vkzln41i4";
+  };
+
+  buildFlags = [ "mnexec" ];
+  makeFlags = [ "PREFIX=$(out)" ];
+
+  pythonPath = [ python.pkgs.setuptools ];
+  buildInputs = [ python which help2man ];
+
+  installTargets = [ "install-mnexec" "install-manpages" ];
+
+  preInstall = ''
+    mkdir -p $out $py
+    # without --root, install fails
+    ${pyEnv.interpreter} setup.py install --root="/" --prefix=$py
+  '';
+
+  doCheck = false;
+
+
+  meta = with lib; {
+    description = "Emulator for rapid prototyping of Software Defined Networks";
+    license = {
+      fullName = "Mininet 2.3.0d4 License";
+    };
+    homepage = https://github.com/mininet/mininet;
+    maintainers = with maintainers; [ teto ];
+  };
+}

pkgs/top-level/all-packages.nix

···
 
   metabase = callPackage ../servers/metabase { };
 
+  miniserve = callPackage ../tools/misc/miniserve { };
+
   mkspiffs = callPackage ../tools/filesystems/mkspiffs { };
 
   mkspiffs-presets = recurseIntoAttrs (callPackages ../tools/filesystems/mkspiffs/presets.nix { });
···
     # and enable
     # customConfig = builtins.readFile ./dvtm.config.h;
   };
+
+  dvtm-unstable = callPackage ../tools/misc/dvtm/unstable.nix {};
 
   ecmtools = callPackage ../tools/cd-dvd/ecm-tools { };
 
···
 
   mdbtools = callPackage ../tools/misc/mdbtools { };
 
-  mdbtools_git = callPackage ../tools/misc/mdbtools/git.nix {
-    inherit (gnome2) scrollkeeper;
-  };
-
   mdk = callPackage ../development/tools/mdk { };
 
   mdp = callPackage ../applications/misc/mdp { };
···
 
   xsel = callPackage ../tools/misc/xsel { };
 
-  xsv = callPackage ../tools/text/xsv { };
+  xsv = callPackage ../tools/text/xsv {
+    inherit (darwin.apple_sdk.frameworks) Security;
+  };
 
   xtreemfs = callPackage ../tools/filesystems/xtreemfs {
     boost = boost165;
···
 
   defaultCrateOverrides = callPackage ../build-support/rust/default-crate-overrides.nix { };
 
+  makeRustPlatform = callPackage ../build-support/rust/make-rust-platform.nix {};
   rustPlatform = recurseIntoAttrs (makeRustPlatform rust);
 
-  makeRustPlatform = rust: lib.fix (self:
-    let
-      callPackage = newScope self;
-    in {
-      inherit rust;
-
-      buildRustPackage = callPackage ../build-support/rust {
-        inherit rust;
-      };
-
-      rustcSrc = callPackage ../development/compilers/rust/rust-src.nix {
-        inherit (rust) rustc;
-      };
-    });
-
   cargo-download = callPackage ../tools/package-management/cargo-download { };
   cargo-edit = callPackage ../tools/package-management/cargo-edit { };
   cargo-release = callPackage ../tools/package-management/cargo-release { };
···
   };
 
   arb = callPackage ../development/libraries/arb {};
-  arb-git = callPackage ../development/libraries/arb/git.nix {};
 
   argp-standalone = callPackage ../development/libraries/argp-standalone {};
 
···
     inherit (darwin) cf-private;
     inherit (darwin.apple_sdk.frameworks) Cocoa AGL GLUT;
   };
+  fltk14 = callPackage ../development/libraries/fltk/1.4.nix {
+    inherit (darwin) cf-private;
+    inherit (darwin.apple_sdk.frameworks) Cocoa AGL GLUT;
+  };
   fltk = self.fltk13;
 
   flyway = callPackage ../development/tools/flyway { };
···
   libviper = callPackage ../development/libraries/libviper { };
 
   libvpx = callPackage ../development/libraries/libvpx { };
-  libvpx-git = callPackage ../development/libraries/libvpx/git.nix { };
 
   libvterm = callPackage ../development/libraries/libvterm { };
   libvterm-neovim = callPackage ../development/libraries/libvterm-neovim { };
···
 
   antiword = callPackage ../applications/office/antiword {};
 
-  ao = callPackage ../applications/graphics/ao {};
+  ao = libfive;
 
   apache-directory-studio = callPackage ../applications/networking/apache-directory-studio {};
 
···
   manuskript = callPackage ../applications/editors/manuskript { };
 
   manul = callPackage ../development/tools/manul { };
+
+  mindforger = libsForQt5.callPackage ../applications/editors/mindforger { };
 
   mi2ly = callPackage ../applications/audio/mi2ly {};
 
···
 
   transgui = callPackage ../applications/networking/p2p/transgui { };
 
+  traverso = libsForQt5.callPackage ../applications/audio/traverso { };
+
   trayer = callPackage ../applications/window-managers/trayer { };
 
   tree = callPackage ../tools/system/tree {};
···
 
   roxterm = callPackage ../applications/misc/roxterm {
     inherit (gnome3) gsettings-desktop-schemas vte;
+  };
+
+  termonad-with-packages = callPackage ../applications/misc/termonad {
+    inherit (haskellPackages) ghcWithPackages;
   };
 
   xtrace = callPackage ../tools/X11/xtrace { };
···
 
   scotch = callPackage ../applications/science/math/scotch { };
 
+  mininet = callPackage ../tools/virtualization/mininet { };
+
   msieve = callPackage ../applications/science/math/msieve { };
 
   weka = callPackage ../applications/science/math/weka { };
···
   golly-beta = callPackage ../applications/science/misc/golly/beta.nix { wxGTK = wxGTK30; };
 
   megam = callPackage ../applications/science/misc/megam { };
+
+  netlogo = callPackage ../applications/science/misc/netlogo { };
 
   ns-3 = callPackage ../development/libraries/science/networking/ns3 { };
 
···
   maphosts = callPackage ../tools/networking/maphosts {};
 
   zimg = callPackage ../development/libraries/zimg { };
+
+  wtf = callPackage ../applications/misc/wtf { };
 
   zk-shell = callPackage ../applications/misc/zk-shell { };
 

pkgs/top-level/haskell-packages.nix

···
 let
   # These are attributes in compiler and packages that don't support integer-simple.
   integerSimpleExcludes = [
-    "ghc821Binary"
+    "ghc822Binary"
     "ghc844"
     "ghcjs"
     "ghcjs82"
···
 
   compiler = {
 
-    ghc821Binary = callPackage ../development/compilers/ghc/8.2.1-binary.nix { };
+    ghc822Binary = callPackage ../development/compilers/ghc/8.2.2-binary.nix { };
 
     ghc822 = callPackage ../development/compilers/ghc/8.2.2.nix {
-      bootPkgs = packages.ghc821Binary;
+      bootPkgs = packages.ghc822Binary;
       inherit (buildPackages.python3Packages) sphinx;
       buildLlvmPackages = buildPackages.llvmPackages_39;
       llvmPackages = pkgs.llvmPackages_39;
     };
     ghc844 = callPackage ../development/compilers/ghc/8.4.4.nix {
-      bootPkgs = packages.ghc821Binary;
+      bootPkgs = packages.ghc822Binary;
       buildLlvmPackages = buildPackages.llvmPackages_5;
       llvmPackages = pkgs.llvmPackages_5;
     };
···
       llvmPackages = pkgs.llvmPackages_6;
     };
     ghcHEAD = callPackage ../development/compilers/ghc/head.nix {
-      bootPkgs = packages.ghc821Binary;
+      bootPkgs = packages.ghc822Binary;
       buildLlvmPackages = buildPackages.llvmPackages_5;
       llvmPackages = pkgs.llvmPackages_5;
     };
···
   # Always get compilers from `buildPackages`
   packages = let bh = buildPackages.haskell; in {
 
-    ghc821Binary = callPackage ../development/haskell-modules {
-      buildHaskellPackages = bh.packages.ghc821Binary;
-      ghc = bh.compiler.ghc821Binary;
+    ghc822Binary = callPackage ../development/haskell-modules {
+      buildHaskellPackages = bh.packages.ghc822Binary;
+      ghc = bh.compiler.ghc822Binary;
       compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-8.2.x.nix { };
       packageSetConfig = bootstrapPackageSet;
     };

pkgs/top-level/metrics.nix

···
     run nix-env.qa nix-env -f ${nixpkgs} -qa
     run nix-env.qaDrv nix-env -f ${nixpkgs} -qa --drv-path --meta --xml
 
+    num=$(nix-env -f ${nixpkgs} -qa | wc -l)
+    echo "nix-env.qaCount $num" >> $out/nix-support/hydra-metrics
+
     export GC_INITIAL_HEAP_SIZE=128k
     run nix-env.qaAggressive nix-env -f ${nixpkgs} -qa
     run nix-env.qaDrvAggressive nix-env -f ${nixpkgs} -qa --drv-path --meta --xml

pkgs/top-level/php-packages.nix

···
       inherit php;
       inherit (pkgs) stdenv autoreconfHook fetchurl;
     };
-  isPhpOlder55 = pkgs.lib.versionOlder php.version "5.5";
-  isPhp7 = pkgs.lib.versionAtLeast php.version "7.0";
 
-  apcu = if isPhp7 then apcu51 else apcu40;
-
-  apcu40 = assert !isPhp7; buildPecl {
-    name = "apcu-4.0.11";
-    sha256 = "002d1gklkf0z170wkbhmm2z1p9p5ghhq3q1r9k54fq1sq4p30ks5";
-    buildInputs = [ pkgs.pcre ];
-    makeFlags = [ "phpincludedir=$(dev)/include" ];
-    outputs = [ "out" "dev" ];
-  };
-
-  apcu51 = assert isPhp7; buildPecl {
+  apcu = buildPecl {
     name = "apcu-5.1.11";
     sha256 = "0nz9m3fbxgyc2ij63yqmxm06a1f51g8rkxk85f85ziqdin66q2f1";
     buildInputs = [ pkgs.pcre ];
···
     buildInputs = [ apcu pkgs.pcre ];
   };
 
-  ast = assert isPhp7; buildPecl {
+  ast = buildPecl {
     name = "ast-0.1.5";
 
     sha256 = "0vv2w5fkkw9n7qdmi5aq50416zxmvyzjym8kb6j1v8kd4xcsjjgw";
···
     ];
   };
 
-  php_excel = assert isPhp7; buildPecl rec {
+  php_excel = buildPecl rec {
     name = "php_excel-${version}";
     version = "1.0.2";
     phpVersion = "php7";
···
     sha256 = "0a55l4f0bgbf3f6sh34njd14niwagg829gfkvb8n5fs69xqab67d";
   };
 
-  mailparse = assert isPhp7; buildPecl {
+  mailparse = buildPecl {
     name = "mailparse-3.0.2";
 
     sha256 = "0fw447ralqihsjnn0fm2hkaj8343cvb90v0d1wfclgz49256y6nq";
···
     buildInputs = [ pkgs.pcre ];
   };
 
-  # No support for PHP 7 yet
-  memcache = assert !isPhp7; buildPecl {
-    name = "memcache-3.0.8";
-
-    sha256 = "04c35rj0cvq5ygn2jgmyvqcb0k8d03v4k642b6i37zgv7x15pbic";
-
-    configureFlags = [ "--with-zlib-dir=${pkgs.zlib.dev}" ];
-
-    makeFlags = [ "CFLAGS=-fgnu89-inline" ];
-  };
-
-  memcached = if isPhp7 then memcachedPhp7 else memcached22;
-
-  memcached22 = assert !isPhp7; buildPecl {
-    name = "memcached-2.2.0";
-
-    sha256 = "0n4z2mp4rvrbmxq079zdsrhjxjkmhz6mzi7mlcipz02cdl7n1f8p";
-
-    configureFlags = [
-      "--with-zlib-dir=${pkgs.zlib.dev}"
-      "--with-libmemcached-dir=${pkgs.libmemcached}"
-    ];
-
-    nativeBuildInputs = [ pkgs.pkgconfig ];
-    buildInputs = with pkgs; [ cyrus_sasl zlib ];
-  };
-
-  # Not released yet
-  memcachedPhp7 = assert isPhp7; buildPecl rec {
+  memcached = buildPecl rec {
     name = "memcached-php7";
 
     src = fetchgit {
···
     sha256 = "0d4p1gpl8gkzdiv860qzxfz250ryf0wmjgyc8qcaaqgkdyh5jy5p";
   };
 
-  # No support for PHP 7 yet (and probably never will be)
-  spidermonkey = assert !isPhp7; buildPecl rec {
-    name = "spidermonkey-1.0.0";
-
-    sha256 = "1ywrsp90w6rlgq3v2vmvp2zvvykkgqqasab7h9bf3vgvgv3qasbg";
-
-    configureFlags = [
-      "--with-spidermonkey=${pkgs.spidermonkey_1_8_5}"
-    ];
-
-    buildInputs = [ pkgs.spidermonkey_1_8_5 ];
-  };
-
-  xdebug = if isPhp7 then xdebug26 else xdebug23;
-
-  xdebug23 = assert !isPhp7; buildPecl {
-    name = "xdebug-2.3.1";
-
-    sha256 = "0k567i6w7cw14m13s7ip0946pvy5ii16cjwjcinnviw9c24na0xm";
-
-    doCheck = true;
-    checkTarget = "test";
-  };
-
-  xdebug26 = assert isPhp7; buildPecl {
+  xdebug = buildPecl {
     name = "xdebug-2.6.1";
 
     sha256 = "0xxxy6n4lv7ghi9liqx133yskg07lw316vhcds43n1sjq3b93rns";
···
     checkTarget = "test";
   };
 
-  yaml = if isPhp7 then yaml20 else yaml13;
-
-  yaml13 = assert !isPhp7; buildPecl {
-    name = "yaml-1.3.1";
-
-    sha256 = "1fbmgsgnd6l0d4vbjaca0x9mrfgl99yix5yf0q0pfcqzfdg4bj8q";
-
-    configureFlags = [
-      "--with-yaml=${pkgs.libyaml}"
-    ];
-
-    nativeBuildInputs = [ pkgs.pkgconfig ];
-  };
-
-  yaml20 = assert isPhp7; buildPecl {
+  yaml = buildPecl {
     name = "yaml-2.0.2";
 
     sha256 = "0f80zy79kyy4hn6iigpgfkwppwldjfj5g7s4gddklv3vskdb1by3";
···
     nativeBuildInputs = [ pkgs.pkgconfig ];
   };
 
-  # Since PHP 5.5 OPcache is integrated in the core and has to be enabled via --enable-opcache during compilation.
-  zendopcache = assert isPhpOlder55; buildPecl {
-    name = "zendopcache-7.0.3";
-
-    sha256 = "0qpfbkfy4wlnsfq4vc4q5wvaia83l89ky33s08gqrcfp3p1adn88";
-  };
-
   zmq = buildPecl {
     name = "zmq-1.1.3";
 
···
     nativeBuildInputs = [ pkgs.pkgconfig ];
   };
 
-  # No support for PHP 7 and probably never will be
-  xcache = assert !isPhp7; buildPecl rec {
-    name = "xcache-${version}";
-
-    version = "3.2.0";
-
-    src = pkgs.fetchurl {
-      url = "http://xcache.lighttpd.net/pub/Releases/${version}/${name}.tar.bz2";
-      sha256 = "1gbcpw64da9ynjxv70jybwf9y88idm01kb16j87vfagpsp5s64kx";
-    };
-
-    doCheck = true;
-    checkTarget = "test";
-
-    configureFlags = [
-      "--enable-xcache"
-      "--enable-xcache-coverager"
-      "--enable-xcache-optimizer"
-      "--enable-xcache-assembler"
-      "--enable-xcache-encoder"
-      "--enable-xcache-decoder"
-    ];
-
-    buildInputs = [ pkgs.m4 ];
-  };
-
-  #pthreads requires a build of PHP with ZTS (Zend Thread Safety) enabled
-  #--enable-maintainer-zts or --enable-zts on Windows
-  pthreads = if isPhp7 then pthreads31 else pthreads20;
-
-  pthreads20 = assert (pkgs.config.php.zts or false) && (!isPhp7); buildPecl {
-    name = "pthreads-2.0.10";
-    sha256 = "1xlcb1b1g10jd0xhm3c01a06yqpb5qln47pd1k522138324qvpwb";
-  };
-
-  pthreads31 = assert (pkgs.config.php.zts or false) && isPhp7; buildPecl {
+  pthreads = assert (pkgs.config.php.zts or false); buildPecl {
     name = "pthreads-3.1.5";
     sha256 = "1ziap0py3zrc7qj9lw4nzq6wx1viyj8v9y1babchizzan014x6p5";
-  };
-
-  # No support for PHP 7 yet
-  geoip = assert !isPhp7; buildPecl {
-    name = "geoip-1.1.0";
-    sha256 = "1fcqpsvwba84gqqmwyb5x5xhkazprwkpsnn4sv2gfbsd4svxxil2";
-
-    configureFlags = [ "--with-geoip=${pkgs.geoip}" ];
-
-    buildInputs = [ pkgs.geoip ];
-  };
-
-  redis = if isPhp7 then redis31 else redis22;
-
-  redis22 = assert !isPhp7; buildPecl {
-    name = "redis-2.2.7";
-    sha256 = "00n9dpk9ak0bl35sbcd3msr78sijrxdlb727nhg7f2g7swf37rcm";
+    meta.broken = true;
   };
 
-  redis31 = assert isPhp7; buildPecl {
+  redis = buildPecl {
     name = "redis-3.1.4";
     sha256 = "0rgjdrqfif8pfn3ipk1v4gyjkkdcdrdk479qbpda89w25vaxzsxd";
   };
 
-  v8 = assert isPhp7; buildPecl rec {
+  v8 = buildPecl rec {
     version = "0.1.9";
     name = "v8-${version}";
 
···
     configureFlags = [ "--with-v8=${pkgs.v8_6_x}" ];
   };
 
-  v8js = assert isPhp7; buildPecl rec {
+  v8js = buildPecl rec {
     version = "1.4.1";
     name = "v8js-${version}";
 

pkgs/top-level/python-packages.nix

···
 
   monty = callPackage ../development/python-modules/monty { };
 
+  mininet-python = (toPythonModule (pkgs.mininet.override{ inherit python; })).py;
+
   mpi4py = callPackage ../development/python-modules/mpi4py {
     mpi = pkgs.openmpi;
   };
···
   unifi = callPackage ../development/python-modules/unifi { };
 
   vidstab = callPackage ../development/python-modules/vidstab { };
+
+  webapp2 = callPackage ../development/python-modules/webapp2 { };
 
   pyunbound = callPackage ../tools/networking/unbound/python.nix { };
 
···
 
   google_auth = callPackage ../development/python-modules/google_auth { };
 
+  google_cloud_asset = callPackage ../development/python-modules/google_cloud_asset { };
+
+  google_cloud_automl = callPackage ../development/python-modules/google_cloud_automl { };
+
   google_cloud_core = callPackage ../development/python-modules/google_cloud_core { };
 
+  google_cloud_bigquery = callPackage ../development/python-modules/google_cloud_bigquery { };
+
+  google_cloud_bigquery_datatransfer = callPackage ../development/python-modules/google_cloud_bigquery_datatransfer { };
+
+  google_cloud_bigtable = callPackage ../development/python-modules/google_cloud_bigtable { };
+
+  google_cloud_container = callPackage ../development/python-modules/google_cloud_container { };
+
+  google_cloud_dataproc = callPackage ../development/python-modules/google_cloud_dataproc { };
+
+  google_cloud_datastore = callPackage ../development/python-modules/google_cloud_datastore { };
+
+  google_cloud_dlp = callPackage ../development/python-modules/google_cloud_dlp { };
+
+  google_cloud_dns = callPackage ../development/python-modules/google_cloud_dns { };
+
+  google_cloud_error_reporting = callPackage ../development/python-modules/google_cloud_error_reporting { };
+
+  google_cloud_firestore = callPackage ../development/python-modules/google_cloud_firestore { };
+
+  google_cloud_iot = callPackage ../development/python-modules/google_cloud_iot { };
+
+  google_cloud_kms = callPackage ../development/python-modules/google_cloud_kms { };
+
+  google_cloud_language = callPackage ../development/python-modules/google_cloud_language { };
+
+  google_cloud_logging = callPackage ../development/python-modules/google_cloud_logging { };
+
+  google_cloud_monitoring = callPackage ../development/python-modules/google_cloud_monitoring { };
+
+  google_cloud_pubsub = callPackage ../development/python-modules/google_cloud_pubsub { };
+
+  google_cloud_redis = callPackage ../development/python-modules/google_cloud_redis { };
+
+  google_cloud_resource_manager = callPackage ../development/python-modules/google_cloud_resource_manager { };
+
+  google_cloud_runtimeconfig = callPackage ../development/python-modules/google_cloud_runtimeconfig { };
+
+  google_cloud_securitycenter = callPackage ../development/python-modules/google_cloud_securitycenter { };
+
+  google_cloud_spanner = callPackage ../development/python-modules/google_cloud_spanner { };
+
+  google_cloud_storage = callPackage ../development/python-modules/google_cloud_storage { };
+
   google_cloud_speech = callPackage ../development/python-modules/google_cloud_speech { };
 
-  gpgme = toPythonModule (pkgs.gpgme.override {
-    pythonSupport = true;
-    inherit (self) python;
-  });
+  google_cloud_tasks = callPackage ../development/python-modules/google_cloud_tasks { };
+
+  google_cloud_testutils = callPackage ../development/python-modules/google_cloud_testutils { };
+
+  google_cloud_texttospeech = callPackage ../development/python-modules/google_cloud_texttospeech { };
+
+  google_cloud_trace = callPackage ../development/python-modules/google_cloud_trace { };
+
+  google_cloud_translate = callPackage ../development/python-modules/google_cloud_translate { };
+
+  google_cloud_videointelligence = callPackage ../development/python-modules/google_cloud_videointelligence { };
+
+  google_cloud_vision = callPackage ../development/python-modules/google_cloud_vision { };
+
+  google_cloud_websecurityscanner = callPackage ../development/python-modules/google_cloud_websecurityscanner { };
+
+  google_resumable_media = callPackage ../development/python-modules/google_resumable_media { };
+
+  gpgme = toPythonModule (pkgs.gpgme.override { pythonSupport=true; });
 
   gphoto2 = callPackage ../development/python-modules/gphoto2 {
     inherit (pkgs) pkgconfig;
···
   grpcio = callPackage ../development/python-modules/grpcio { };
 
   grpcio-tools = callPackage ../development/python-modules/grpcio-tools { };
+
+  grpcio-gcp = callPackage ../development/python-modules/grpcio-gcp { };
+
+  grpc_google_iam_v1 = callPackage ../development/python-modules/grpc_google_iam_v1 { };
 
   gspread = callPackage ../development/python-modules/gspread { };