Merge branch 'master' into staging

.github/CODEOWNERS

···
 /pkgs/development/haskell-modules/generic-builder.nix @peti @ryantm @basvandijk
 /pkgs/development/haskell-modules/hoogle.nix          @peti @ryantm @basvandijk
 
+# Perl
+/pkgs/development/interpreters/perl @volth
+/pkgs/top-level/perl-packages.nix   @volth
+/pkgs/development/perl-modules      @volth
+
 # R
 /pkgs/applications/science/math/R   @peti
 /pkgs/development/r-modules         @peti
 
 # Ruby
-/pkgs/development/interpreters/ruby @zimbatm
-/pkgs/development/ruby-modules      @zimbatm
+/pkgs/development/interpreters/ruby @alyssais @zimbatm
+/pkgs/development/ruby-modules      @alyssais @zimbatm
 
 # Rust
 /pkgs/development/compilers/rust @Mic92 @LnL7

doc/languages-frameworks/python.section.md

···
 ### Interpreters
 
 Versions 2.7, 3.5, 3.6 and 3.7 of the CPython interpreter are available as
-respectively `python27`, `python35`, `python36`, and `python37`. The PyPy
-interpreter is available as `pypy`. The aliases `python2` and `python3`
-correspond to respectively `python27` and `python37`. The default interpreter,
-`python`, maps to `python2`. The Nix expressions for the interpreters can be
+respectively `python27`, `python35`, `python36` and `python37`. The aliases
+`python2` and `python3` correspond to respectively `python27` and
+`python37`. The default interpreter, `python`, maps to `python2`. The PyPy
+interpreters compatible with Python 2.7 and 3 are available as `pypy27` and
+`pypy3`, with aliases `pypy2` mapping to `pypy27` and `pypy` mapping to
+`pypy2`. The Nix expressions for the interpreters can be
 found in `pkgs/development/interpreters/python`.
 
 All packages depending on any Python interpreter get appended
···
 The following is an overlay that configures `numpy` to use `mkl`:
 ```nix
 self: super: {
-  python36 = super.python36.override {
+  python37 = super.python37.override {
     packageOverrides = python-self: python-super: {
       numpy = python-super.numpy.override {
         blas = super.pkgs.mkl;
···
   };
 }
 ```
+
+`mkl` requires an `openmp` implementation when running with multiple processors.
+By default, `mkl` will use Intel's `iomp` implementation if no other is
+specified, but this is a runtime-only dependency and binary compatible with the
+LLVM implementation. To use that one instead, Intel recommends users set it with
+`LD_PRELOAD`.
+
+Note that `mkl` is only available on `x86_64-{linux,darwin}` platforms;
+moreover, Hydra is not building and distributing pre-compiled binaries using it.
 
 ## Contributing
 

maintainers/maintainer-list.nix

···
     github = "AndrewMorsillo";
     name = "Andrew Morsillo";
   };
+  andersk = {
+    email = "[e-mail]";
+    github = "andersk";
+    name = "Anders Kaseorg";
+  };
   AndersonTorres = {
     email = "[e-mail]";
     github = "AndersonTorres";
···
     email = "[e-mail]";
     github = "ellis";
     name = "Ellis Whitehead";
+  };
+  elohmeier = {
+    email = "[e-mail]";
+    github = "elohmeier";
+    name = "Enno Lohmeier";
   };
   elseym = {
     email = "[e-mail]";

nixos/doc/manual/release-notes/rl-1903.xml

···
      <literal>./programs/nm-applet.nix</literal>
     </para>
    </listitem>
+   <listitem>
+    <para>
+     There is a new <varname>security.googleOsLogin</varname> module for using
+     <link xlink:href="https://cloud.google.com/compute/docs/instances/managing-instance-access">OS Login</link>
+     to manage SSH access to Google Compute Engine instances, which supersedes
+     the imperative and broken <literal>google-accounts-daemon</literal> used
+     in <literal>nixos/modules/virtualisation/google-compute-config.nix</literal>.
+    </para>
+   </listitem>
   </itemizedlist>
  </section>
 
···
      path. Regenerate the <literal>authorized_keys</literal> file via
      <command>sudo -u git -H gitlab-rake gitlab:shell:setup</command> in that
      case.
+   </para>
+  </listitem>
+  <listitem>
+   <para>
+     The <literal>pam_unix</literal> account module is now loaded with its
+     control field set to <literal>required</literal> instead of
+     <literal>sufficient</literal>, so that later pam account modules that
+     might do more extensive checks are being executed.
+     Previously, the whole account module verification was exited prematurely
+     in case a nss module provided the account name to
+     <literal>pam_unix</literal>.
+     The LDAP and SSSD NixOS modules already add their NSS modules when
+     enabled. In case your setup breaks due to some later pam account module
+     previosuly shadowed, or failing NSS lookups, please file a bug. You can
+     get back the old behaviour by manually setting
+     <literal><![CDATA[security.pam.services.<name?>.text]]></literal>.
    </para>
   </listitem>
   </itemizedlist>

nixos/lib/testing.nix

···
 
       vms = map (m: m.config.system.build.vm) (lib.attrValues nodes);
 
-      ocrProg = tesseract_4.override { enableLanguages = [ "eng" ]; };
+      ocrProg = tesseract4.override { enableLanguages = [ "eng" ]; };
 
       imagemagick_tiff = imagemagick_light.override { inherit libtiff; };
 

nixos/lib/utils.nix

···
                      || elem fs.mountPoint [ "/" "/nix" "/nix/store" "/var" "/var/log" "/var/lib" "/etc" ];
 
   # Check whenever `b` depends on `a` as a fileSystem
-  # FIXME: it's incorrect to simply use hasPrefix here: "/dev/a" is not a parent of "/dev/ab"
-  fsBefore = a: b: ((any (x: elem x [ "bind" "move" ]) b.options) && (a.mountPoint == b.device))
-                || (hasPrefix a.mountPoint b.mountPoint);
+  fsBefore = a: b: a.mountPoint == b.device
+                || hasPrefix "${a.mountPoint}${optionalString (!(hasSuffix "/" a.mountPoint)) "/"}" b.mountPoint;
 
   # Escape a path according to the systemd rules, e.g. /dev/xyzzy
   # becomes dev-xyzzy.  FIXME: slow.

nixos/modules/config/nsswitch.nix

···
 # Configuration for the Name Service Switch (/etc/nsswitch.conf).
 
-{ config, lib, ... }:
+{ config, lib, pkgs, ... }:
 
 with lib;
 
···
   ldap = canLoadExternalModules && (config.users.ldap.enable && config.users.ldap.nsswitch);
   sssd = canLoadExternalModules && config.services.sssd.enable;
   resolved = canLoadExternalModules && config.services.resolved.enable;
+  googleOsLogin = canLoadExternalModules && config.security.googleOsLogin.enable;
 
   hostArray = [ "files" ]
     ++ optional mymachines "mymachines"
···
     ++ optional sssd "sss"
     ++ optional ldap "ldap"
     ++ optional mymachines "mymachines"
+    ++ optional googleOsLogin "cache_oslogin oslogin"
     ++ [ "systemd" ];
 
   shadowArray = [ "files" ]
···
     # configured IP addresses, or ::1 and 127.0.0.2 as
     # fallbacks. Systemd also provides nss-mymachines to return IP
     # addresses of local containers.
-    system.nssModules = optionals canLoadExternalModules [ config.systemd.package.out ];
-
+    system.nssModules = (optionals canLoadExternalModules [ config.systemd.package.out ])
+      ++ optional googleOsLogin pkgs.google-compute-engine-oslogin.out;
   };
 }

nixos/modules/module-list.nix

···
   ./security/chromium-suid-sandbox.nix
   ./security/dhparams.nix
   ./security/duosec.nix
+  ./security/google_oslogin.nix
   ./security/hidepid.nix
   ./security/lock-kernel-modules.nix
   ./security/misc.nix
···
   ./services/hardware/usbmuxd.nix
   ./services/hardware/thermald.nix
   ./services/hardware/undervolt.nix
+  ./services/hardware/vdr.nix
   ./services/logging/SystemdJournal2Gelf.nix
   ./services/logging/awstats.nix
   ./services/logging/fluentd.nix

nixos/modules/security/google_oslogin.nix

···
+{ config, lib, pkgs, ... }:
+
+with lib;
+
+let
+
+  cfg = config.security.googleOsLogin;
+  package = pkgs.google-compute-engine-oslogin;
+
+in
+
+{
+
+  options = {
+
+    security.googleOsLogin.enable = mkOption {
+      type = types.bool;
+      default = false;
+      description = ''
+        Whether to enable Google OS Login
+
+        The OS Login package enables the following components:
+        AuthorizedKeysCommand to query valid SSH keys from the user's OS Login
+        profile during ssh authentication phase.
+        NSS Module to provide user and group information
+        PAM Module for the sshd service, providing authorization and
+        authentication support, allowing the system to use data stored in
+        Google Cloud IAM permissions to control both, the ability to log into
+        an instance, and to perform operations as root (sudo).
+      '';
+    };
+
+  };
+
+  config = mkIf cfg.enable {
+    security.pam.services.sshd = {
+      makeHomeDir = true;
+      googleOsLoginAccountVerification = true;
+      # disabled for now: googleOsLoginAuthentication = true;
+    };
+
+    security.sudo.extraConfig = ''
+      #includedir /run/google-sudoers.d
+    '';
+    systemd.tmpfiles.rules = [
+      "d /run/google-sudoers.d 750 root root -"
+      "d /var/google-users.d 750 root root -"
+    ];
+
+    # enable the nss module, so user lookups etc. work
+    system.nssModules = [ package ];
+
+    # Ugly: sshd refuses to start if a store path is given because /nix/store is group-writable.
+    # So indirect by a symlink.
+    environment.etc."ssh/authorized_keys_command_google_oslogin" = {
+      mode = "0755";
+      text = ''
+        #!/bin/sh
+        exec ${package}/bin/google_authorized_keys "$@"
+      '';
+    };
+    services.openssh.extraConfig = ''
+      AuthorizedKeysCommand /etc/ssh/authorized_keys_command_google_oslogin %u
+      AuthorizedKeysCommandUser nobody
+    '';
+  };
+
+}

nixos/modules/security/pam.nix

···
         '';
       };
 
+      googleOsLoginAccountVerification = mkOption {
+        default = false;
+        type = types.bool;
+        description = ''
+          If set, will use the Google OS Login PAM modules
+          (<literal>pam_oslogin_login</literal>,
+          <literal>pam_oslogin_admin</literal>) to verify possible OS Login
+          users and set sudoers configuration accordingly.
+          This only makes sense to enable for the <literal>sshd</literal> PAM
+          service.
+        '';
+      };
+
+      googleOsLoginAuthentication = mkOption {
+        default = false;
+        type = types.bool;
+        description = ''
+          If set, will use the <literal>pam_oslogin_login</literal>'s user
+          authentication methods to authenticate users using 2FA.
+          This only makes sense to enable for the <literal>sshd</literal> PAM
+          service.
+        '';
+      };
+
       fprintAuth = mkOption {
         default = config.services.fprintd.enable;
         type = types.bool;
···
       text = mkDefault
         (''
           # Account management.
-          account ${if cfg.sssdStrictAccess then "required" else "sufficient"} pam_unix.so
+          account required pam_unix.so
           ${optionalString use_ldap
               "account sufficient ${pam_ldap}/lib/security/pam_ldap.so"}
           ${optionalString (config.services.sssd.enable && cfg.sssdStrictAccess==false)
···
               "account [default=bad success=ok user_unknown=ignore] ${pkgs.sssd}/lib/security/pam_sss.so"}
           ${optionalString config.krb5.enable
               "account sufficient ${pam_krb5}/lib/security/pam_krb5.so"}
+          ${optionalString cfg.googleOsLoginAccountVerification ''
+            account [success=ok ignore=ignore default=die] ${pkgs.google-compute-engine-oslogin}/lib/pam_oslogin_login.so
+            account [success=ok default=ignore] ${pkgs.google-compute-engine-oslogin}/lib/pam_oslogin_admin.so
+          ''}
 
           # Authentication management.
+          ${optionalString cfg.googleOsLoginAuthentication
+              "auth [success=done perm_denied=bad default=ignore] ${pkgs.google-compute-engine-oslogin}/lib/pam_oslogin_login.so"}
           ${optionalString cfg.rootOK
               "auth sufficient pam_rootok.so"}
           ${optionalString cfg.requireWheel

nixos/modules/services/databases/aerospike.nix

···
 
       package = mkOption {
         default = pkgs.aerospike;
+        defaultText = "pkgs.aerospike";
         type = types.package;
         description = "Which Aerospike derivation to use";
       };

nixos/modules/services/databases/clickhouse.nix

···
       };
     };
 
+    environment.systemPackages = [ pkgs.clickhouse ];
+
+    # startup requires a `/etc/localtime` which only if exists if `time.timeZone != null`
+    time.timeZone = mkDefault "UTC";
+
   };
 
 }

nixos/modules/services/hardware/vdr.nix

···
+{ config, lib, pkgs, ... }:
+
+with lib;
+
+let
+  cfg = config.services.vdr;
+  libDir = "/var/lib/vdr";
+in {
+
+  ###### interface
+
+  options = {
+
+    services.vdr = {
+      enable = mkEnableOption "enable VDR. Please put config into ${libDir}.";
+
+      package = mkOption {
+        type = types.package;
+        default = pkgs.vdr;
+        defaultText = "pkgs.vdr";
+        example = literalExample "pkgs.wrapVdr.override { plugins = with pkgs.vdrPlugins; [ hello ]; }";
+        description = "Package to use.";
+      };
+
+      videoDir = mkOption {
+        type = types.path;
+        default = "/srv/vdr/video";
+        description = "Recording directory";
+      };
+
+      extraArguments = mkOption {
+        type = types.listOf types.str;
+        default = [];
+        description = "Additional command line arguments to pass to VDR.";
+      };
+    };
+  };
+
+  ###### implementation
+
+  config = mkIf cfg.enable {
+    systemd.tmpfiles.rules = [
+      "d ${cfg.videoDir} 0755 vdr vdr -"
+      "Z ${cfg.videoDir} - vdr vdr -"
+    ];
+
+    systemd.services.vdr = {
+      description = "VDR";
+      wantedBy = [ "multi-user.target" ];
+      serviceConfig = {
+        ExecStart = ''
+          ${cfg.package}/bin/vdr \
+            --video="${cfg.videoDir}" \
+            --config="${libDir}" \
+            ${escapeShellArgs cfg.extraArguments}
+        '';
+        User = "vdr";
+        CacheDirectory = "vdr";
+        StateDirectory = "vdr";
+        Restart = "on-failure";
+      };
+    };
+
+    users.users.vdr = {
+      group = "vdr";
+      home = libDir;
+    };
+
+    users.groups.vdr = {};
+  };
+}

nixos/modules/services/network-filesystems/ipfs.nix

···
 
     services.ipfs = {
 
-      enable = mkEnableOption "Interplanetary File System";
+      enable = mkEnableOption "Interplanetary File System (WARNING: may cause severe network degredation)";
 
       user = mkOption {
         type = types.str;

nixos/modules/services/networking/shairport-sync.nix

···
       };
 
       arguments = mkOption {
-        default = "-v -d pulse";
+        default = "-v pulse";
         description = ''
           Arguments to pass to the daemon. Defaults to a local pulseaudio
           server.

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

···
         ${xorg.lndir}/bin/lndir ${pkg}/share/xsessions $out/share/xsessions
       '') cfg.displayManager.extraSessionFilePackages}
 
-      mkdir -p "$out/share/wayland-sessions"
+      
       ${concatMapStrings (pkg: ''
-        ${xorg.lndir}/bin/lndir ${pkg}/share/wayland-sessions $out/share/wayland-sessions
+        if test -d ${pkg}/share/wayland-sessions; then
+          mkdir -p "$out/share/wayland-sessions"
+          ${xorg.lndir}/bin/lndir ${pkg}/share/wayland-sessions $out/share/wayland-sessions
+        fi
       '') cfg.displayManager.extraSessionFilePackages}
     '';
 

nixos/modules/virtualisation/google-compute-config.nix

···
   # GC has 1460 MTU
   networking.interfaces.eth0.mtu = 1460;
 
-  # allow the google-accounts-daemon to manage users
-  users.mutableUsers = true;
-  # and allow users to sudo without password
-  security.sudo.enable = true;
-  security.sudo.extraConfig = ''
-  %google-sudoers ALL=(ALL:ALL) NOPASSWD:ALL
-  '';
-
-  # NOTE: google-accounts tries to write to /etc/sudoers.d but the folder doesn't exist
-  # FIXME: not such file or directory on dynamic SSH provisioning
-  systemd.services.google-accounts-daemon = {
-    description = "Google Compute Engine Accounts Daemon";
-    # This daemon creates dynamic users
-    enable = config.users.mutableUsers;
-    after = [
-      "network.target"
-      "google-instance-setup.service"
-      "google-network-setup.service"
-    ];
-    requires = ["network.target"];
-    wantedBy = ["multi-user.target"];
-    path = with pkgs; [ shadow ];
-    serviceConfig = {
-      Type = "simple";
-      ExecStart = "${gce}/bin/google_accounts_daemon --debug";
-    };
-  };
+  security.googleOsLogin.enable = true;
 
   systemd.services.google-clock-skew-daemon = {
     description = "Google Compute Engine Clock Skew Daemon";

nixos/release-combined.nix

···
 { nixpkgs ? { outPath = (import ../lib).cleanSource ./..; revCount = 56789; shortRev = "gfedcba"; }
 , stableBranch ? false
 , supportedSystems ? [ "x86_64-linux" ]
-, limitedSupportedSystems ? [ "i686-linux" ]
+, limitedSupportedSystems ? [ "i686-linux" "aarch64-linux" ]
 }:
 
 let
···
     };
     constituents =
       let
-        all = x: map (system: x.${system}) supportedSystems;
+        # Except for the given systems, return the system-specific constituent
+        except = systems: x: map (system: x.${system}) (pkgs.lib.subtractLists systems supportedSystems);
+        all = x: except [] x;
       in [
         nixos.channel
         (all nixos.dummy)
         (all nixos.manual)
 
-        nixos.iso_minimal.x86_64-linux or []
-        nixos.iso_minimal.i686-linux or []
         nixos.iso_graphical.x86_64-linux or []
+        nixos.iso_minimal.aarch64-linux or []
+        nixos.iso_minimal.i686-linux or []
+        nixos.iso_minimal.x86_64-linux or []
         nixos.ova.x86_64-linux or []
+        nixos.sd_image.aarch64-linux or []
 
         #(all nixos.tests.containers)
         (all nixos.tests.containers-imperative)
···
         nixos.tests.chromium.x86_64-linux or []
         (all nixos.tests.firefox)
         (all nixos.tests.firewall)
-        (all nixos.tests.gnome3)
+        (except ["aarch64-linux"] nixos.tests.gnome3)
         nixos.tests.installer.zfsroot.x86_64-linux or [] # ZFS is 64bit only
-        (all nixos.tests.installer.lvm)
-        (all nixos.tests.installer.luksroot)
-        (all nixos.tests.installer.separateBoot)
-        (all nixos.tests.installer.separateBootFat)
-        (all nixos.tests.installer.simple)
-        (all nixos.tests.installer.simpleLabels)
-        (all nixos.tests.installer.simpleProvided)
-        (all nixos.tests.installer.simpleUefiSystemdBoot)
-        (all nixos.tests.installer.swraid)
-        (all nixos.tests.installer.btrfsSimple)
-        (all nixos.tests.installer.btrfsSubvols)
-        (all nixos.tests.installer.btrfsSubvolDefault)
-        (all nixos.tests.boot.biosCdrom)
-        #(all nixos.tests.boot.biosUsb) # disabled due to issue #15690
-        (all nixos.tests.boot.uefiCdrom)
-        (all nixos.tests.boot.uefiUsb)
+        (except ["aarch64-linux"] nixos.tests.installer.lvm)
+        (except ["aarch64-linux"] nixos.tests.installer.luksroot)
+        (except ["aarch64-linux"] nixos.tests.installer.separateBoot)
+        (except ["aarch64-linux"] nixos.tests.installer.separateBootFat)
+        (except ["aarch64-linux"] nixos.tests.installer.simple)
+        (except ["aarch64-linux"] nixos.tests.installer.simpleLabels)
+        (except ["aarch64-linux"] nixos.tests.installer.simpleProvided)
+        (except ["aarch64-linux"] nixos.tests.installer.simpleUefiSystemdBoot)
+        (except ["aarch64-linux"] nixos.tests.installer.swraid)
+        (except ["aarch64-linux"] nixos.tests.installer.btrfsSimple)
+        (except ["aarch64-linux"] nixos.tests.installer.btrfsSubvols)
+        (except ["aarch64-linux"] nixos.tests.installer.btrfsSubvolDefault)
+        (except ["aarch64-linux"] nixos.tests.boot.biosCdrom)
+        #(except ["aarch64-linux"] nixos.tests.boot.biosUsb) # disabled due to issue #15690
+        (except ["aarch64-linux"] nixos.tests.boot.uefiCdrom)
+        (except ["aarch64-linux"] nixos.tests.boot.uefiUsb)
         (all nixos.tests.boot-stage1)
         (all nixos.tests.hibernate)
         nixos.tests.docker.x86_64-linux or []
···
 
         nixpkgs.tarball
         (all allSupportedNixpkgs.emacs)
-        (all allSupportedNixpkgs.jdk)
+        # The currently available aarch64 JDK is unfree
+        (except ["aarch64-linux"] allSupportedNixpkgs.jdk)
       ];
   });
 

nixos/release.nix

···
 
   # A variant with a more recent (but possibly less stable) kernel
   # that might support more hardware.
-  iso_minimal_new_kernel = forMatchingSystems [ "x86_64-linux" ] (system: makeIso {
+  iso_minimal_new_kernel = forMatchingSystems [ "x86_64-linux" "aarch64-linux" ] (system: makeIso {
     module = ./modules/installer/cd-dvd/installation-cd-minimal-new-kernel.nix;
     type = "minimal-new-kernel";
     inherit system;
···
       { services.httpd.enable = true;
         services.httpd.adminAddr = "[e-mail]";
         services.postgresql.enable = true;
-        services.postgresql.package = pkgs.postgresql_9_3;
+        services.postgresql.package = pkgs.postgresql;
         environment.systemPackages = [ pkgs.php ];
       });
   };

nixos/tests/all-tests.nix

···
   cfssl = handleTestOn ["x86_64-linux"] ./cfssl.nix {};
   chromium = (handleTestOn ["x86_64-linux"] ./chromium.nix {}).stable or {};
   cjdns = handleTest ./cjdns.nix {};
+  clickhouse = handleTest ./clickhouse.nix {};
   cloud-init = handleTest ./cloud-init.nix {};
   codimd = handleTest ./codimd.nix {};
   containers-bridge = handleTest ./containers-bridge.nix {};
···
   gitlab = handleTest ./gitlab.nix {};
   gitolite = handleTest ./gitolite.nix {};
   gjs = handleTest ./gjs.nix {};
+  google-oslogin = handleTest ./google-oslogin {};
   gnome3 = handleTestOn ["x86_64-linux"] ./gnome3.nix {}; # libsmbios is unsupported on aarch64
   gnome3-gdm = handleTestOn ["x86_64-linux"] ./gnome3-gdm.nix {}; # libsmbios is unsupported on aarch64
   gocd-agent = handleTest ./gocd-agent.nix {};

nixos/tests/clickhouse.nix

···
+import ./make-test.nix ({ pkgs, ... }: {
+  name = "clickhouse";
+  meta.maintainers = with pkgs.stdenv.lib.maintainers; [ ma27 ];
+
+  machine = {
+    services.clickhouse.enable = true;
+  };
+
+  testScript =
+    let
+      # work around quote/substitution complexity by Nix, Perl, bash and SQL.
+      tableDDL = pkgs.writeText "ddl.sql" "CREATE TABLE `demo` (`value` FixedString(10)) engine = MergeTree PARTITION BY value ORDER BY tuple();";
+      insertQuery = pkgs.writeText "insert.sql" "INSERT INTO `demo` (`value`) VALUES ('foo');";
+      selectQuery = pkgs.writeText "select.sql" "SELECT * from `demo`";
+    in
+      ''
+        $machine->start();
+        $machine->waitForUnit("clickhouse.service");
+        $machine->waitForOpenPort(9000);
+
+        $machine->succeed("cat ${tableDDL} | clickhouse-client");
+        $machine->succeed("cat ${insertQuery} | clickhouse-client");
+        $machine->succeed("cat ${selectQuery} | clickhouse-client | grep foo");
+      '';
+})

nixos/tests/google-oslogin/default.nix

···
+import ../make-test.nix ({ pkgs, ... } :
+let
+  inherit (import ./../ssh-keys.nix pkgs)
+    snakeOilPrivateKey snakeOilPublicKey;
+in {
+  name = "google-oslogin";
+  meta = with pkgs.stdenv.lib.maintainers; {
+    maintainers = [ adisbladis flokli ];
+  };
+
+  nodes = {
+    # the server provides both the the mocked google metadata server and the ssh server
+    server = (import ./server.nix pkgs);
+
+    client = { ... }: {};
+  };
+  testScript =  ''
+    startAll;
+
+    $server->waitForUnit("mock-google-metadata.service");
+    $server->waitForOpenPort(80);
+
+    # mockserver should return a non-expired ssh key for both mockuser and mockadmin
+    $server->succeed('${pkgs.google-compute-engine-oslogin}/bin/google_authorized_keys mockuser | grep -q "${snakeOilPublicKey}"');
+    $server->succeed('${pkgs.google-compute-engine-oslogin}/bin/google_authorized_keys mockadmin | grep -q "${snakeOilPublicKey}"');
+
+    # install snakeoil ssh key on the client
+    $client->succeed("mkdir -p ~/.ssh");
+    $client->succeed("cat ${snakeOilPrivateKey} > ~/.ssh/id_snakeoil");
+    $client->succeed("chmod 600 ~/.ssh/id_snakeoil");
+
+    $client->waitForUnit("network.target");
+    $server->waitForUnit("sshd.service");
+
+    # we should not be able to connect as non-existing user
+    $client->fail("ssh -o User=ghost -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no server -i ~/.ssh/id_snakeoil 'true'");
+
+    # we should be able to connect as mockuser
+    $client->succeed("ssh -o User=mockuser -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no server -i ~/.ssh/id_snakeoil 'true'");
+    # but we shouldn't be able to sudo
+    $client->fail("ssh -o User=mockuser -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no server -i ~/.ssh/id_snakeoil '/run/wrappers/bin/sudo /run/current-system/sw/bin/id' | grep -q 'root'");
+
+    # we should also be able to log in as mockadmin
+    $client->succeed("ssh -o User=mockadmin -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no server -i ~/.ssh/id_snakeoil 'true'");
+    # pam_oslogin_admin.so should now have generated a sudoers file
+    $server->succeed("find /run/google-sudoers.d | grep -q '/run/google-sudoers.d/mockadmin'");
+
+    # and we should be able to sudo
+    $client->succeed("ssh -o User=mockadmin -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no server -i ~/.ssh/id_snakeoil '/run/wrappers/bin/sudo /run/current-system/sw/bin/id' | grep -q 'root'");
+  '';
+  })
+

nixos/tests/google-oslogin/server.nix

···
+{ pkgs, ... }:
+let
+  inherit (import ./../ssh-keys.nix pkgs)
+    snakeOilPrivateKey snakeOilPublicKey;
+in {
+  networking.firewall.allowedTCPPorts = [ 80 ];
+
+  systemd.services.mock-google-metadata = {
+    description = "Mock Google metadata service";
+    serviceConfig.Type = "simple";
+    serviceConfig.ExecStart = "${pkgs.python3}/bin/python ${./server.py}";
+    environment = {
+      SNAKEOIL_PUBLIC_KEY = snakeOilPublicKey;
+    };
+    wantedBy = [ "multi-user.target" ];
+    after = [ "network.target" ];
+  };
+
+  services.openssh.enable = true;
+  services.openssh.challengeResponseAuthentication = false;
+  services.openssh.passwordAuthentication = false;
+
+  security.googleOsLogin.enable = true;
+
+  # Mock google service
+  networking.extraHosts = ''
+    127.0.0.1 metadata.google.internal
+  '';
+}

nixos/tests/google-oslogin/server.py

···
+#!/usr/bin/env python3
+import json
+import sys
+import time
+import os
+import hashlib
+import base64
+
+from http.server import BaseHTTPRequestHandler, HTTPServer
+from typing import Dict
+
+SNAKEOIL_PUBLIC_KEY = os.environ['SNAKEOIL_PUBLIC_KEY']
+
+
+def w(msg):
+    sys.stderr.write(f"{msg}\n")
+    sys.stderr.flush()
+
+
+def gen_fingerprint(pubkey):
+    decoded_key = base64.b64decode(pubkey.encode("ascii").split()[1])
+    return hashlib.sha256(decoded_key).hexdigest()
+
+def gen_email(username):
+    """username seems to be a 21 characters long number string, so mimic that in a reproducible way"""
+    return str(int(hashlib.sha256(username.encode()).hexdigest(), 16))[0:21]
+
+def gen_mockuser(username: str, uid: str, gid: str, home_directory: str, snakeoil_pubkey: str) -> Dict:
+    snakeoil_pubkey_fingerprint = gen_fingerprint(snakeoil_pubkey)
+    # seems to be a 21 characters long numberstring, so mimic that in a reproducible way
+    email = gen_email(username)
+    return {
+        "loginProfiles": [
+            {
+                "name": email,
+                "posixAccounts": [
+                    {
+                        "primary": True,
+                        "username": username,
+                        "uid": uid,
+                        "gid": gid,
+                        "homeDirectory": home_directory,
+                        "operatingSystemType": "LINUX"
+                    }
+                ],
+                "sshPublicKeys": {
+                    snakeoil_pubkey_fingerprint: {
+                        "key": snakeoil_pubkey,
+                        "expirationTimeUsec": str((time.time() + 600) * 1000000),  # 10 minutes in the future
+                        "fingerprint": snakeoil_pubkey_fingerprint
+                    }
+                }
+            }
+        ]
+    }
+
+
+class ReqHandler(BaseHTTPRequestHandler):
+    def _send_json_ok(self, data):
+        self.send_response(200)
+        self.send_header('Content-type', 'application/json')
+        self.end_headers()
+        out = json.dumps(data).encode()
+        w(out)
+        self.wfile.write(out)
+
+    def do_GET(self):
+        p = str(self.path)
+        # mockuser and mockadmin are allowed to login, both use the same snakeoil public key
+        if p == '/computeMetadata/v1/oslogin/users?username=mockuser' \
+            or p == '/computeMetadata/v1/oslogin/users?uid=1009719690':
+            self._send_json_ok(gen_mockuser(username='mockuser', uid='1009719690', gid='1009719690',
+                                            home_directory='/home/mockuser', snakeoil_pubkey=SNAKEOIL_PUBLIC_KEY))
+        elif p == '/computeMetadata/v1/oslogin/users?username=mockadmin' \
+            or p == '/computeMetadata/v1/oslogin/users?uid=1009719691':
+            self._send_json_ok(gen_mockuser(username='mockadmin', uid='1009719691', gid='1009719691',
+                                            home_directory='/home/mockadmin', snakeoil_pubkey=SNAKEOIL_PUBLIC_KEY))
+
+        # mockuser is allowed to login
+        elif p == f"/computeMetadata/v1/oslogin/authorize?email={gen_email('mockuser')}&policy=login":
+            self._send_json_ok({'success': True})
+
+        # mockadmin may also become root
+        elif p == f"/computeMetadata/v1/oslogin/authorize?email={gen_email('mockadmin')}&policy=login" or p == f"/computeMetadata/v1/oslogin/authorize?email={gen_email('mockadmin')}&policy=adminLogin":
+            self._send_json_ok({'success': True})
+        else:
+            sys.stderr.write(f"Unhandled path: {p}\n")
+            sys.stderr.flush()
+            self.send_response(501)
+            self.end_headers()
+            self.wfile.write(b'')
+
+
+if __name__ == '__main__':
+    s = HTTPServer(('0.0.0.0', 80), ReqHandler)
+    s.serve_forever()

nixos/tests/home-assistant.nix

···
   configDir = "/var/lib/foobar";
   apiPassword = "some_secret";
   mqttPassword = "another_secret";
+  hassCli = "hass-cli --server http://hass:8123 --password '${apiPassword}'";
 
 in {
   name = "home-assistant";
···
       { pkgs, ... }:
       {
         environment.systemPackages = with pkgs; [
-          mosquitto
+          mosquitto home-assistant-cli
         ];
         services.home-assistant = {
           inherit configDir;
···
     $hass->succeed("curl http://localhost:8123/api/states/binary_sensor.mqtt_binary_sensor -H 'x-ha-access: ${apiPassword}' | grep -qF '\"state\": \"off\"'");
     $hass->waitUntilSucceeds("mosquitto_pub -V mqttv311 -t home-assistant/test -u homeassistant -P '${mqttPassword}' -m let_there_be_light");
     $hass->succeed("curl http://localhost:8123/api/states/binary_sensor.mqtt_binary_sensor -H 'x-ha-access: ${apiPassword}' | grep -qF '\"state\": \"on\"'");
+
+    # Toggle a binary sensor using hass-cli
+    $hass->succeed("${hassCli} entity get binary_sensor.mqtt_binary_sensor | grep -qF '\"state\": \"on\"'");
+    $hass->succeed("${hassCli} entity edit binary_sensor.mqtt_binary_sensor --json='{\"state\": \"off\"}'");
+    $hass->succeed("curl http://localhost:8123/api/states/binary_sensor.mqtt_binary_sensor -H 'x-ha-access: ${apiPassword}' | grep -qF '\"state\": \"off\"'");
 
     # Print log to ease debugging
     my $log = $hass->succeed("cat ${configDir}/home-assistant.log");

pkgs/applications/audio/ams-lv2/default.nix

···
     license = licenses.gpl3;
     maintainers = [ maintainers.goibhniu ];
     platforms = platforms.linux;
+    # Build uses `-msse` and `-mfpmath=sse`
+    badPlatforms = [ "aarch64-linux" ];
   };
 }

pkgs/applications/audio/artyFX/default.nix

···
     license = licenses.gpl2;
     maintainers = [ maintainers.magnetophon ];
     platforms = platforms.linux;
+    # Build uses `-msse` and `-mfpmath=sse`
+    badPlatforms = [ "aarch64-linux" ];
   };
 }

pkgs/applications/audio/lmms/default.nix

···
 { stdenv, fetchFromGitHub, cmake, pkgconfig, alsaLib ? null, fftwFloat, fltk13
-, fluidsynth ? null, lame ? null, libgig ? null, libjack2 ? null, libpulseaudio ? null
+, fluidsynth_1 ? null, lame ? null, libgig ? null, libjack2 ? null, libpulseaudio ? null
 , libsamplerate, libsoundio ? null, libsndfile, libvorbis ? null, portaudio ? null
 , qtbase, qtx11extras, qttools, SDL ? null }:
 
 stdenv.mkDerivation rec {
   name = "lmms-${version}";
-  version = "1.2.0-rc6";
+  version = "1.2.0-rc7";
 
   src = fetchFromGitHub {
     owner = "LMMS";
     repo = "lmms";
     rev = "v${version}";
-    sha256 = "1pqir5srfrknfd8nmbz565ymq18ffw8d8k9pbmzggaxvlcr12b25";
+    sha256 = "1hshzf2sbdfw37y9rz1ksgvn81kp2n23dp74lsaasc2n7wzjwdis";
     fetchSubmodules = true;
   };
 
···
     alsaLib
     fftwFloat
     fltk13
-    fluidsynth
+    fluidsynth_1
     lame
     libgig
     libjack2

pkgs/applications/audio/lollypop/default.nix

···
 
 python3.pkgs.buildPythonApplication rec  {
   pname = "lollypop";
-  version = "0.9.611";
+  version = "0.9.906";
 
   format = "other";
   doCheck = false;
···
     url = "https://gitlab.gnome.org/World/lollypop";
     rev = "refs/tags/${version}";
     fetchSubmodules = true;
-    sha256 = "1k78a26sld0xd14c9hr4qv8c7qaq1m8zqk1mzrh4pl7ysqqg9p20";
+    sha256 = "1blfq3vdzs3ji3sr1z6dn5c2f8w93zv2k7aa5xpfpfnds4zfd3q6";
   };
 
   nativeBuildInputs = with python3.pkgs; [

pkgs/applications/audio/qmmp/default.nix

···
 # handle that.
 
 stdenv.mkDerivation rec {
-  name = "qmmp-1.2.4";
+  name = "qmmp-1.2.5";
 
   src = fetchurl {
     url = "http://qmmp.ylsoftware.com/files/${name}.tar.bz2";
-    sha256 = "0rmfd6h0186b6n4g079d8kshdmp3k5n8w06a1l41m4p3fgq08j92";
+    sha256 = "1xs8kg65088yzdhdkymmknkp1s4adzv095f5jhjvy62s8ymyjvnx";
   };
 
   buildInputs =

pkgs/applications/audio/rosegarden/default.nix

···
 , liblo, liblrdf, libsamplerate, libsndfile, lirc ? null, qtbase }:
 
 stdenv.mkDerivation (rec {
-  version = "18.06";
+  version = "18.12";
   name = "rosegarden-${version}";
 
   src = fetchurl {
     url = "mirror://sourceforge/rosegarden/${name}.tar.bz2";
-    sha256 = "04qc80sqb2ji42pq3mayhvqqn39hlxzymsywpbpzfpchr19chxx7";
+    sha256 = "15i9fm0vkn3wsgahaxqi1j5zs0wc0j3wdwml0x49084gk2p328vb";
   };
 
   patchPhase = ''

pkgs/applications/audio/whipper/default.nix

···
 
 python2.pkgs.buildPythonApplication rec {
   name = "whipper-${version}";
-  version = "0.7.2";
+  version = "0.7.3";
 
   src = fetchFromGitHub {
     owner = "whipper-team";
     repo = "whipper";
     rev = "v${version}";
-    sha256 = "17cn11c6c62pfhhp6vcslxpanb0czh2xbxq1g6wd7bpmgw38yd8v";
+    sha256 = "0ypbgc458i7yvbyvg6wg6agz5yzlwm1v6zw7fmyq9h59xsv27mpr";
   };
 
   pythonPath = with python2.pkgs; [

pkgs/applications/editors/android-studio/default.nix

···
     sha256Hash = "117skqjax1xz9plarhdnrw2rwprjpybdc7mx7wggxapyy920vv5r";
   };
   betaVersion = {
-    version = "3.3.0.18"; # "Android Studio 3.3 RC 2"
-    build = "182.5160847";
-    sha256Hash = "05rjwvcph0wx0p0hai5z6n9lnyhk3i5yvbvhr51jc8s3k3b6jyi5";
+    version = "3.3.0.19"; # "Android Studio 3.3 RC 3"
+    build = "182.5183351";
+    sha256Hash = "1rql4kxjic4qjcd8zssw2mmi55cxpzd0wp5g0kzwk5wybsfdcqhy";
   };
   latestVersion = { # canary & dev
-    version = "3.4.0.7"; # "Android Studio 3.4 Canary 8"
-    build = "183.5173923";
-    sha256Hash = "0bf96c9db15rw1k1znz6yxhbrn9q990zy3pkq0nsirnqfpgllvpi";
+    version = "3.4.0.8"; # "Android Studio 3.4 Canary 9"
+    build = "183.5186062";
+    sha256Hash = "04i7ys0qzj3039h41q4na6737gl55wpp6hiwfas2h6zwvj25a9z9";
   };
 in rec {
   # Old alias

pkgs/applications/editors/emacs-modes/elpa-generated.nix

···
       elpaBuild {
         pname = "ada-mode";
         ename = "ada-mode";
-        version = "5.3.2";
+        version = "6.0.1";
         src = fetchurl {
-          url = "https://elpa.gnu.org/packages/ada-mode-5.3.2.tar";
-          sha256 = "1ayp4y8q201fny2far9p2ziji968f2svr7apvfrlwnnpkk3w9lif";
+          url = "https://elpa.gnu.org/packages/ada-mode-6.0.1.tar";
+          sha256 = "12ryblyqnhqibaffibs7qq3xq9rf5d4y9dishq82pbbh9y8s17hj";
         };
         packageRequires = [ cl-lib emacs wisi ];
         meta = {
···
       elpaBuild {
         pname = "company";
         ename = "company";
-        version = "0.9.7";
+        version = "0.9.9";
         src = fetchurl {
-          url = "https://elpa.gnu.org/packages/company-0.9.7.tar";
-          sha256 = "17p61yzbgymr46y6vbz7pfvydp5hfkqckbwficwkpz0nq8gcklhs";
+          url = "https://elpa.gnu.org/packages/company-0.9.9.tar";
+          sha256 = "1qinkz8gwgc27p3p3c9kddrrwx0jb4w0vgx7jq8fwpfj1n92m1rv";
         };
         packageRequires = [ emacs ];
         meta = {
···
           license = lib.licenses.free;
         };
       }) {};
-    diff-hl = callPackage ({ cl-lib ? null, elpaBuild, fetchurl, lib }:
+    diff-hl = callPackage ({ cl-lib ? null, elpaBuild, emacs, fetchurl, lib }:
       elpaBuild {
         pname = "diff-hl";
         ename = "diff-hl";
-        version = "1.8.4";
+        version = "1.8.5";
         src = fetchurl {
-          url = "https://elpa.gnu.org/packages/diff-hl-1.8.4.tar";
-          sha256 = "0axhidc3cym7a2x4rpxf4745qss9s9ajyg4s9h5b4zn7v7fyp71n";
+          url = "https://elpa.gnu.org/packages/diff-hl-1.8.5.tar";
+          sha256 = "1vxc7z7c2qs0mx7l5sa4sybi5qbzv0s79flj74p1ynw8dl3qxg3d";
         };
-        packageRequires = [ cl-lib ];
+        packageRequires = [ cl-lib emacs ];
         meta = {
           homepage = "https://elpa.gnu.org/packages/diff-hl.html";
           license = lib.licenses.free;
···
       elpaBuild {
         pname = "ebdb";
         ename = "ebdb";
-        version = "0.6";
+        version = "0.6.2";
         src = fetchurl {
-          url = "https://elpa.gnu.org/packages/ebdb-0.6.tar";
-          sha256 = "1zj8jvq5l4wlk4734i3isxi4barpivarq2f9kqzkfia7mcspxav8";
+          url = "https://elpa.gnu.org/packages/ebdb-0.6.2.tar";
+          sha256 = "1b37962mvm80vk5sdk9kfvvxsxn83z5z6zvm20m9997ggl5dv4dz";
         };
         packageRequires = [ cl-lib emacs seq ];
         meta = {
···
           license = lib.licenses.free;
         };
       }) {};
-    eglot = callPackage ({ elpaBuild, emacs, fetchurl, jsonrpc, lib }:
+    eglot = callPackage ({ elpaBuild
+                         , emacs
+                         , fetchurl
+                         , flymake ? null
+                         , jsonrpc
+                         , lib }:
       elpaBuild {
         pname = "eglot";
         ename = "eglot";
-        version = "1.1";
+        version = "1.3";
         src = fetchurl {
-          url = "https://elpa.gnu.org/packages/eglot-1.1.tar";
-          sha256 = "01h4wh87lrd9l50y20gjjkgg760v8ixvbcb3q8jykl29989zw62y";
+          url = "https://elpa.gnu.org/packages/eglot-1.3.tar";
+          sha256 = "0hndqabxvrq4ak5kx2xlds5pkayi2bfd1f1xk8aidzk5i70f7yry";
         };
-        packageRequires = [ emacs jsonrpc ];
+        packageRequires = [ emacs flymake jsonrpc ];
         meta = {
           homepage = "https://elpa.gnu.org/packages/eglot.html";
           license = lib.licenses.free;
···
       elpaBuild {
         pname = "el-search";
         ename = "el-search";
-        version = "1.7.15";
+        version = "1.8.7";
         src = fetchurl {
-          url = "https://elpa.gnu.org/packages/el-search-1.7.15.tar";
-          sha256 = "000z8vllz53vmfblsrxjm2nc4h9lcyxw8xxqfxxyl99zhfiikjai";
+          url = "https://elpa.gnu.org/packages/el-search-1.8.7.tar";
+          sha256 = "0jlalcz8hppra2chmppd6b2g5dz8w6yscqylkx28pd7wy6aadx1r";
         };
         packageRequires = [ cl-print emacs stream ];
         meta = {
···
       elpaBuild {
         pname = "exwm";
         ename = "exwm";
-        version = "0.20";
+        version = "0.21";
         src = fetchurl {
-          url = "https://elpa.gnu.org/packages/exwm-0.20.tar";
-          sha256 = "0nhhzbkm0mkj7sd1dy2c19cmn56gyaj9nl8kgy86h4fp63hjaz04";
+          url = "https://elpa.gnu.org/packages/exwm-0.21.tar";
+          sha256 = "07ng1pgsnc3isfsyzh2gfc7391p9il8lb5xqf1z6yqn20w7k6xzj";
         };
         packageRequires = [ xelb ];
         meta = {
···
         packageRequires = [ cl-lib emacs ];
         meta = {
           homepage = "https://elpa.gnu.org/packages/flylisp.html";
+          license = lib.licenses.free;
+        };
+      }) {};
+    flymake = callPackage ({ elpaBuild, emacs, fetchurl, lib }:
+      elpaBuild {
+        pname = "flymake";
+        ename = "flymake";
+        version = "1.0.3";
+        src = fetchurl {
+          url = "https://elpa.gnu.org/packages/flymake-1.0.3.el";
+          sha256 = "1algny2zhcl4vc7kp5czcqvxzpgqfjnz2rnkv26r0ylxig3s98v7";
+        };
+        packageRequires = [ emacs ];
+        meta = {
+          homepage = "https://elpa.gnu.org/packages/flymake.html";
           license = lib.licenses.free;
         };
       }) {};
···
       elpaBuild {
         pname = "gnorb";
         ename = "gnorb";
-        version = "1.6.0";
+        version = "1.6.1";
         src = fetchurl {
-          url = "https://elpa.gnu.org/packages/gnorb-1.6.0.tar";
-          sha256 = "0nssrnrf083mw7kllp0hkxdkklvildzmslcs1r3zf2hnl1ggfs8y";
+          url = "https://elpa.gnu.org/packages/gnorb-1.6.1.tar";
+          sha256 = "0n4460hsmcc3l0y3nb3fysvh33cjwgv0a3mkc26xcx8v85zl7m63";
         };
         packageRequires = [ cl-lib ];
         meta = {
···
       elpaBuild {
         pname = "gnus-mock";
         ename = "gnus-mock";
-        version = "0.3.0";
+        version = "0.4.0";
         src = fetchurl {
-          url = "https://elpa.gnu.org/packages/gnus-mock-0.3.0.tar";
-          sha256 = "02z3f8njwv480fff57dbrf7nhmwbgm4apzicnzwmip5j4a6w5q0n";
+          url = "https://elpa.gnu.org/packages/gnus-mock-0.4.0.tar";
+          sha256 = "058bd4f8za9bxayrd2j5b05qvk8lxxm8mmfwxb73d7k15z3z3l3s";
         };
         packageRequires = [];
         meta = {
           homepage = "https://elpa.gnu.org/packages/gnus-mock.html";
+          license = lib.licenses.free;
+        };
+      }) {};
+    gpastel = callPackage ({ elpaBuild, emacs, fetchurl, lib }:
+      elpaBuild {
+        pname = "gpastel";
+        ename = "gpastel";
+        version = "0.3.0";
+        src = fetchurl {
+          url = "https://elpa.gnu.org/packages/gpastel-0.3.0.el";
+          sha256 = "0426y55f7mbfbyjhl2bn0c2cn57jd4d8xvzri2pbqakff8ij470a";
+        };
+        packageRequires = [ emacs ];
+        meta = {
+          homepage = "https://elpa.gnu.org/packages/gpastel.html";
           license = lib.licenses.free;
         };
       }) {};
···
       elpaBuild {
         pname = "jsonrpc";
         ename = "jsonrpc";
-        version = "1.0.6";
+        version = "1.0.7";
         src = fetchurl {
-          url = "https://elpa.gnu.org/packages/jsonrpc-1.0.6.el";
-          sha256 = "13a19smz8cksv6fgcyxb111csvagkp07z5nl4imyp5b23asgl70p";
+          url = "https://elpa.gnu.org/packages/jsonrpc-1.0.7.el";
+          sha256 = "19z35gjphl4mlgpznfhlccgipnmbb3c1dvax48f4hw8qwksfcac1";
         };
         packageRequires = [ emacs ];
         meta = {
···
       elpaBuild {
         pname = "nhexl-mode";
         ename = "nhexl-mode";
-        version = "1.0";
+        version = "1.2";
         src = fetchurl {
-          url = "https://elpa.gnu.org/packages/nhexl-mode-1.0.el";
-          sha256 = "1bf0jfim41m08ac4p4zxjj6qqw7f86gwiwyvfjg68n2nzbzgz1i9";
+          url = "https://elpa.gnu.org/packages/nhexl-mode-1.2.el";
+          sha256 = "031h22p564qdvr9khs05qcba06pmsk68cr7zyc7c04hfr3y3ziaf";
         };
         packageRequires = [ cl-lib emacs ];
         meta = {
···
           license = lib.licenses.free;
         };
       }) {};
+    org-edna = callPackage ({ elpaBuild, emacs, fetchurl, lib, org, seq }:
+      elpaBuild {
+        pname = "org-edna";
+        ename = "org-edna";
+        version = "1.0.1";
+        src = fetchurl {
+          url = "https://elpa.gnu.org/packages/org-edna-1.0.1.tar";
+          sha256 = "0xzyzx3pq1q6d66qcqx38pgxzn160y9yrzpy0ka8ap5xsm7ngn7m";
+        };
+        packageRequires = [ emacs org seq ];
+        meta = {
+          homepage = "https://elpa.gnu.org/packages/org-edna.html";
+          license = lib.licenses.free;
+        };
+      }) {};
     orgalist = callPackage ({ elpaBuild, emacs, fetchurl, lib }:
       elpaBuild {
         pname = "orgalist";
···
       elpaBuild {
         pname = "posframe";
         ename = "posframe";
-        version = "0.3.0";
+        version = "0.4.2";
         src = fetchurl {
-          url = "https://elpa.gnu.org/packages/posframe-0.3.0.el";
-          sha256 = "0q74lwklr29c50qgaqly48nj7f49kgxiv70lsvhdy8cg2v082v8k";
+          url = "https://elpa.gnu.org/packages/posframe-0.4.2.el";
+          sha256 = "1h8vvxvsg41vc1nnglqjs2q0k1yzfsn72skga9s76qa3zxmx6kds";
         };
         packageRequires = [ emacs ];
         meta = {
···
       elpaBuild {
         pname = "ssh-deploy";
         ename = "ssh-deploy";
-        version = "2.0";
+        version = "3.0";
         src = fetchurl {
-          url = "https://elpa.gnu.org/packages/ssh-deploy-2.0.tar";
-          sha256 = "0mrgnandnqk25bx3x2a7hdw7pmjiq24w2lad7l2xqaqpwb8r6wgj";
+          url = "https://elpa.gnu.org/packages/ssh-deploy-3.0.tar";
+          sha256 = "0lv9qwm1dhcd2l2mnhjfpqsz6xx0wabjg5j5sm3425fjsaqws6m7";
         };
         packageRequires = [ emacs ];
         meta = {
···
       elpaBuild {
         pname = "svg";
         ename = "svg";
-        version = "0.1";
+        version = "0.2";
         src = fetchurl {
-          url = "https://elpa.gnu.org/packages/svg-0.1.el";
-          sha256 = "0v27casnjvjjaalmrbw494sk0zciws037cn6cmcc6rnhj30lzbv5";
+          url = "https://elpa.gnu.org/packages/svg-0.2.el";
+          sha256 = "14yfi27v3zdzh1chcjiq4l63iwh0vd99wv1z4w7agr33540jybc5";
         };
         packageRequires = [ emacs ];
         meta = {
···
           license = lib.licenses.free;
         };
       }) {};
+    system-packages = callPackage ({ elpaBuild, emacs, fetchurl, lib }:
+      elpaBuild {
+        pname = "system-packages";
+        ename = "system-packages";
+        version = "1.0.10";
+        src = fetchurl {
+          url = "https://elpa.gnu.org/packages/system-packages-1.0.10.tar";
+          sha256 = "1vwf2j0fxrsqmrgc7x5nkkg0vlhwgxppc4w7kb5is6dgrssskpb5";
+        };
+        packageRequires = [ emacs ];
+        meta = {
+          homepage = "https://elpa.gnu.org/packages/system-packages.html";
+          license = lib.licenses.free;
+        };
+      }) {};
     tNFA = callPackage ({ elpaBuild, fetchurl, lib, queue }:
       elpaBuild {
         pname = "tNFA";
···
           license = lib.licenses.free;
         };
       }) {};
+    vcl-mode = callPackage ({ elpaBuild, fetchurl, lib }:
+      elpaBuild {
+        pname = "vcl-mode";
+        ename = "vcl-mode";
+        version = "1.1";
+        src = fetchurl {
+          url = "https://elpa.gnu.org/packages/vcl-mode-1.1.el";
+          sha256 = "1r70pmvr95k5f2xphvhliqvyh7al0qabm7wvkamximcssvs38q1h";
+        };
+        packageRequires = [];
+        meta = {
+          homepage = "https://elpa.gnu.org/packages/vcl-mode.html";
+          license = lib.licenses.free;
+        };
+      }) {};
     vdiff = callPackage ({ elpaBuild, emacs, fetchurl, hydra, lib }:
       elpaBuild {
         pname = "vdiff";
···
           license = lib.licenses.free;
         };
       }) {};
-    wisi = callPackage ({ cl-lib ? null, elpaBuild, emacs, fetchurl, lib }:
+    wisi = callPackage ({ cl-lib ? null, elpaBuild, emacs, fetchurl, lib, seq }:
       elpaBuild {
         pname = "wisi";
         ename = "wisi";
-        version = "1.1.6";
+        version = "2.0.1";
         src = fetchurl {
-          url = "https://elpa.gnu.org/packages/wisi-1.1.6.tar";
-          sha256 = "0p7hm9l4gbp50rmpqna6jnc1pss2axdd6m6hk9ik4afbz0knzwnk";
+          url = "https://elpa.gnu.org/packages/wisi-2.0.1.tar";
+          sha256 = "1h0g6y33jrafcabgyi7j700hpv4p56v84c2mlqb334k1g9rq3709";
         };
-        packageRequires = [ cl-lib emacs ];
+        packageRequires = [ cl-lib emacs seq ];
         meta = {
           homepage = "https://elpa.gnu.org/packages/wisi.html";
           license = lib.licenses.free;
···
       elpaBuild {
         pname = "xclip";
         ename = "xclip";
-        version = "1.5";
+        version = "1.7";
         src = fetchurl {
-          url = "https://elpa.gnu.org/packages/xclip-1.5.el";
-          sha256 = "1fyqyi0672igjn53xlaj8hzbymkw08pk6wj58ndbrnm410g0h0i9";
+          url = "https://elpa.gnu.org/packages/xclip-1.7.el";
+          sha256 = "0jpy3zzbyb16vqa9l6m45crzlypwvscvs76h8lci7kvp91kq954r";
         };
         packageRequires = [];
         meta = {
···
       elpaBuild {
         pname = "zones";
         ename = "zones";
-        version = "2018.11.13";
+        version = "2018.11.21";
         src = fetchurl {
-          url = "https://elpa.gnu.org/packages/zones-2018.11.13.el";
-          sha256 = "0716m9s5qjp5w3gdlx0p53qrfylw6mhdmic88qmsndmhkijsrax4";
+          url = "https://elpa.gnu.org/packages/zones-2018.11.21.el";
+          sha256 = "0s68mnynjd08gyga7xdnb0zy3irsxl1jryidpcrkzg821vfrk11i";
         };
         packageRequires = [];
         meta = {

pkgs/applications/editors/emacs-modes/org-generated.nix

···
       elpaBuild {
         pname = "org";
         ename = "org";
-        version = "20181119";
+        version = "20181217";
         src = fetchurl {
-          url = "http://orgmode.org/elpa/org-20181119.tar";
-          sha256 = "0li6mx0kv70js3mlw7wxk1yi8kgc3nxnb87kdb7jy68xh4lsila7";
+          url = "http://orgmode.org/elpa/org-20181217.tar";
+          sha256 = "0j301z0429dnk1d3bn7524y848vp9il41sxpm9z9hs7gpzfdcw28";
         };
         packageRequires = [];
         meta = {
···
       elpaBuild {
         pname = "org-plus-contrib";
         ename = "org-plus-contrib";
-        version = "20181119";
+        version = "20181217";
         src = fetchurl {
-          url = "http://orgmode.org/elpa/org-plus-contrib-20181119.tar";
-          sha256 = "0dz0vn2xyidifrwrd604yknyq843i31jcc8qgsi6wib29rh7zzpa";
+          url = "http://orgmode.org/elpa/org-plus-contrib-20181217.tar";
+          sha256 = "1p7v9246zxkp68kc63550x3w7pmhx1drgj20wmddhvs0bqd3k3ap";
         };
         packageRequires = [];
         meta = {

pkgs/applications/editors/ghostwriter/default.nix

···
-{ stdenv, fetchFromGitHub, qmake, pkgconfig, qtwebkit, hunspell }:
+{ stdenv, fetchFromGitHub, qmake, pkgconfig, qttools, qtwebkit, hunspell }:
 
 stdenv.mkDerivation rec {
   pname = "ghostwriter";
···
     sha256 = "1pqlr08z5syqcq5p282asxwzrrm7c1w94baxyb467swh8yp3fj5m";
   };
 
-  nativeBuildInputs = [ qmake pkgconfig ];
+  nativeBuildInputs = [ qmake pkgconfig qttools ];
 
   buildInputs = [ qtwebkit hunspell ];
 

pkgs/applications/editors/gnome-builder/default.nix

···
 , wrapGAppsHook
 }:
 let
-  version = "3.30.0";
+  version = "3.30.2";
   pname = "gnome-builder";
 in stdenv.mkDerivation {
   name = "${pname}-${version}";
 
   src = fetchurl {
     url = "mirror://gnome/sources/${pname}/${stdenv.lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
-    sha256 = "1pshzpjy9rk6gijlm97s316aihykzxrmb07vilp17q5857passak";
+    sha256 = "05yax7iv9g831xvw9xdc01qc0l7qpmh6rfd692x8cbg76hljxdrr";
   };
 
   nativeBuildInputs = [

pkgs/applications/editors/manuskript/default.nix

···
 
 python3Packages.buildPythonApplication rec {
   pname = "manuskript";
-  version = "0.3.0";
+  version = "0.8.0";
 
   src = fetchFromGitHub {
     repo = pname;
     owner = "olivierkes";
     rev = version;
-    sha256 = "0bqxc4a8kyi6xz1zs0dp85wxl9h4v8lzc6073bbcsn1zg4y59ys7";
+    sha256 = "0vqz02p3m9n4hk2jplnklr9s6niqdm5iykab6nblqdm4plb04c34";
   };
 
   propagatedBuildInputs = [

pkgs/applications/graphics/rawtherapee/default.nix

···
 }:
 
 stdenv.mkDerivation rec {
-  version = "5.4";
+  version = "5.5";
   name = "rawtherapee-" + version;
 
   src = fetchFromGitHub {
     owner = "Beep6581";
     repo = "RawTherapee";
     rev = version;
-    sha256 = "1h2x5biqsb4kfwsffqkyk8ky22qv2a0cjs1s445x9farcr3kwk99";
+    sha256 = "13clnx7rwkfa7wxgsim1xdx2pd7gwmmdad1m8a3fvywr20ml8xzk";
   };
 
   nativeBuildInputs = [ cmake pkgconfig wrapGAppsHook ];

pkgs/applications/graphics/tesseract/4.x.nix

···
-{ stdenv, fetchFromGitHub, autoreconfHook, autoconf-archive, pkgconfig
-, leptonica, libpng, libtiff, icu, pango, opencl-headers
-
-# Supported list of languages or `null' for all available languages
-, enableLanguages ? null
-}:
-
-stdenv.mkDerivation rec {
-  name = "tesseract-${version}";
-  version = "4.0.0";
-
-  src = fetchFromGitHub {
-    owner = "tesseract-ocr";
-    repo = "tesseract";
-    rev = version;
-    sha256 = "1b5fi2vibc4kk9b30kkk4ais4bw8fbbv24bzr5709194hb81cav8";
-  };
-
-  tessdata = fetchFromGitHub {
-    owner = "tesseract-ocr";
-    repo = "tessdata";
-    rev = version;
-    sha256 = "1chw1ya5zf8aaj2ixr9x013x7vwwwjjmx6f2ag0d6i14lypygy28";
-  };
-
-  nativeBuildInputs = [ pkgconfig autoreconfHook autoconf-archive ];
-  buildInputs = [ leptonica libpng libtiff icu pango opencl-headers ];
-
-  # Copy the .traineddata files of the languages specified in enableLanguages
-  # into `$out/share/tessdata' and check afterwards if copying was successful.
-  postInstall = let
-    mkArg = lang: "-iname ${stdenv.lib.escapeShellArg "${lang}.traineddata"}";
-    mkFindArgs = stdenv.lib.concatMapStringsSep " -o " mkArg;
-    findLangArgs = if enableLanguages != null
-                   then "\\( ${mkFindArgs enableLanguages} \\)"
-                   else "-iname '*.traineddata'";
-  in ''
-    numLangs="$(find "$tessdata" -mindepth 1 -maxdepth 1 -type f \
-      ${findLangArgs} -exec cp -t "$out/share/tessdata" {} + -print | wc -l)"
-
-    ${if enableLanguages != null then ''
-      expected=${toString (builtins.length enableLanguages)}
-    '' else ''
-      expected="$(ls -1 "$tessdata/"*.traineddata | wc -l)"
-    ''}
-
-    if [ "$numLangs" -ne "$expected" ]; then
-      echo "Expected $expected languages, but $numLangs" \
-           "were copied to \`$out/share/tessdata'" >&2
-      exit 1
-    fi
-  '';
-
-  meta = {
-    description = "OCR engine";
-    homepage = https://github.com/tesseract-ocr/tesseract;
-    license = stdenv.lib.licenses.asl20;
-    maintainers = with stdenv.lib.maintainers; [viric];
-    platforms = with stdenv.lib.platforms; linux;
-  };
-}

pkgs/applications/graphics/tesseract/default.nix

···
-{ stdenv, fetchFromGitHub, autoreconfHook, pkgconfig
-, leptonica, libpng, libtiff, icu, pango, opencl-headers
-# Supported list of languages or `null' for all available languages
-, enableLanguages ? null
-# if you want just a specific list of languages, optionally specify a hash
-# to make tessdata a fixed output derivation.
-, enableLanguagesHash ? (if enableLanguages == null # all languages
-                         then "1h48xfzabhn0ldbx5ib67cp9607pr0zpblsy8z6fs4knn0zznfnw"
-                         else null)
-}:
+{ callPackage, lowPrio }:
 
-let tessdata = stdenv.mkDerivation ({
-  name = "tessdata";
-  src = fetchFromGitHub {
-    owner = "tesseract-ocr";
-    repo = "tessdata";
-    rev = "3cf1e2df1fe1d1da29295c9ef0983796c7958b7d";
-    # when updating don't forget to update the default value fo enableLanguagesHash
-    sha256 = "1v4b63v5nzcxr2y3635r19l7lj5smjmc9vfk0wmxlryxncb4vpg7";
-  };
-  buildCommand = ''
-    cd $src;
-    for lang in ${if enableLanguages==null then "*.traineddata" else stdenv.lib.concatMapStringsSep " " (x: x+".traineddata") enableLanguages} ; do
-      install -Dt $out/share/tessdata $src/$lang ;
-    done;
-  '';
-  preferLocalBuild = true;
-  } // (stdenv.lib.optionalAttrs (enableLanguagesHash != null) {
-  # when a hash is given, we make this a fixed output derivation.
-  outputHashMode = "recursive";
-  outputHashAlgo = "sha256";
-  outputHash = enableLanguagesHash;
-  }));
+let
+  base3 = callPackage ./tesseract3.nix {};
+  base4 = callPackage ./tesseract4.nix {};
+  languages = callPackage ./languages.nix {};
 in
-
-stdenv.mkDerivation rec {
-  name = "tesseract-${version}";
-  version = "3.05.00";
-
-  src = fetchFromGitHub {
-    owner = "tesseract-ocr";
-    repo = "tesseract";
-    rev = version;
-    sha256 = "11wrpcfl118wxsv2c3w2scznwb48c4547qml42s2bpdz079g8y30";
+{
+  tesseract3 = callPackage ./wrapper.nix {
+    tesseractBase = base3;
+    languages = languages.v3;
   };
 
-  enableParallelBuilding = true;
-
-  nativeBuildInputs = [ pkgconfig autoreconfHook ];
-  buildInputs = [ leptonica libpng libtiff icu pango opencl-headers ];
-
-  LIBLEPT_HEADERSDIR = "${leptonica}/include";
-
-  postInstall = ''
-    for i in ${tessdata}/share/tessdata/*; do
-      ln -s $i $out/share/tessdata;
-    done
-  '';
-
-  meta = {
-    description = "OCR engine";
-    homepage = https://github.com/tesseract-ocr/tesseract;
-    license = stdenv.lib.licenses.asl20;
-    maintainers = with stdenv.lib.maintainers; [viric];
-    platforms = with stdenv.lib.platforms; linux ++ darwin;
-  };
+  tesseract4 = lowPrio (callPackage ./wrapper.nix {
+    tesseractBase = base4;
+    languages = languages.v4;
+  });
 }

pkgs/applications/graphics/tesseract/fetch-language-hashes

···
+#!/usr/bin/env bash
+
+# Usage:
+#   ./fetch-language-hashes <tessdataRev> [<language code>…]
+#
+#   Fetches all languages if no language codes are given.
+#
+# Example:
+#   ./fetch-language-hashes 4.0.0 eng spa
+#
+#   Output:
+#     eng = "0iy0...";
+#     spa = "15kw...";
+
+set -e
+
+(( $# >= 1 )) || exit 1
+tessdataRev=$1
+shift
+
+if (( $# > 0 )); then
+    langCodes="$@"
+else
+    repoPage=$(curl -fs https://github.com/tesseract-ocr/tessdata/tree/$tessdataRev || {
+                   >&2 echo "Invalid tessdataRev: $tessdataRev"
+                   exit 1
+               })
+    langCodes=$(echo $(echo "$repoPage" | grep -ohP "(?<=/)[^/]+?(?=\.traineddata)" | sort))
+fi
+
+for lang in $langCodes; do
+    url=https://github.com/tesseract-ocr/tessdata/raw/$tessdataRev/$lang.traineddata
+    hash=$(nix-prefetch-url $url 2>/dev/null)
+    echo "$lang = \"$hash\";"
+done

pkgs/applications/graphics/tesseract/languages.nix

···
+{ stdenv, lib, fetchurl, fetchFromGitHub }:
+
+rec {
+  makeLanguages = { tessdataRev, tessdata ? null, all ? null, languages ? {} }:
+    let
+      tessdataSrc = fetchFromGitHub {
+        owner = "tesseract-ocr";
+        repo = "tessdata";
+        rev = tessdataRev;
+        sha256 = tessdata;
+      };
+
+      languageFile = lang: sha256: fetchurl {
+        url = "https://github.com/tesseract-ocr/tessdata/raw/${tessdataRev}/${lang}.traineddata";
+        inherit sha256;
+      };
+    in
+      {
+        # Use a simple fixed-output derivation for all languages to increase nix eval performance
+        all = stdenv.mkDerivation {
+          name = "all";
+          buildCommand = ''
+            mkdir $out
+            cd ${tessdataSrc}
+            cp *.traineddata $out
+          '';
+          outputHashMode = "recursive";
+          outputHashAlgo = "sha256";
+          outputHash = all;
+        };
+      } // (lib.mapAttrs languageFile languages);
+
+  v3 = makeLanguages {
+    tessdataRev = "3cf1e2df1fe1d1da29295c9ef0983796c7958b7d";
+    tessdata = "1v4b63v5nzcxr2y3635r19l7lj5smjmc9vfk0wmxlryxncb4vpg7";
+    all = "0yj6h9n6h0kzzcqsn3z87vsi8pa60szp0yiayb0znd0v9my0dqhn";
+
+    # Run `./fetch-language-hashes <tessdataRev>` to generate these hashes
+    languages = {
+      afr = "15dsnzy4i9ai26ilm73gkfj4ck039raa88i6w443c4b1fnay2akf";
+      amh = "1wbcsdq3svxga3j1alk61xs72a9fhsfsyjxhp3cwxfaqfhrzg7h4";
+      ara = "0nk495gki6jbbnwcl2ybsx4nd02d6qykcjncq0d2g8pbgapqmj91";
+      asm = "0c3wq15yphq7x74s2sn3f90k6z1cf5j7ic62z0dynidrv99bddfh";
+      aze = "0pz073hxqkx1a1cshlgg5k11lj73s52sdxa7k3020drc314lhaxw";
+      aze_cyrl = "0djbfgx28ykcjsn2p0766qrmj256g7vhc7valc3ivsva8b906lxq";
+      bel = "04zqy8vik0fcakq6apfp8wjhkkhlg0yn9kmag1lk7s8fy9ax3ws2";
+      ben = "0q7812kn5xjm47hcgdcg911lhbgqr7hbvqckfxxm8qw0yjx2cy0m";
+      bod = "0rwq7539zzfs8xs0bf1535z1cwkm0yk1ni25f5gjav7nm6qpiaan";
+      bos = "1qr04dj7lx347gxpin5nfprbggmxq2mwx8kf3pcc3vb5x3pa57g4";
+      bul = "0cyyqgi3i4y9bfzwls0lwljzgd0r8ayfqb4bbvdh4qmbni9x42ya";
+      cat = "0kgw8f5pdw9lfbn6cfp5n1s0j8pj3418yx6rsbagzcf1gr36gbr9";
+      ceb = "1g1n4np4vhar7wfwx2km5k6kldb600rrl7npfbf75229rar068f1";
+      ces = "0zxkkyhpd74i6321nv86pkjb0k7p9cp6m174rbn42nl7jz6qxib0";
+      chi_sim = "0k250xr0gk9yh22yqxd0zpxdsrqfzs164kdv5n9rxx1g996yffij";
+      chi_tra = "03nxqpd546p0gwfj6pqzbdbv5zjpdddzlpa10xn4nvmks1mmckbp";
+      chr = "1k1sg3hap0kd5aa36ysvmhp7r3fynxf0f7lzz814h6p3g250zclb";
+      cym = "0d6wbf9cmrrzf66mhcckwdfy3xh2i38r0by9nk6isw9rl7bf7j07";
+      dan = "1s1yj56rpzmif3ir3qs4iab744cgpflk7y8812z2665bh61illpr";
+      dan_frak = "1bxi53ymib5g0139vfd2pflh7nl5925vqznq3sfgaqx7gdx630vi";
+      deu = "0fna7fqk1a8ivd7q2k38vx37qm3vbn183zh4z5zfqb4pgqmb8znb";
+      deu_frak = "1y4krkvarg7jxhcq49fgybg4phbn58y9c0z2bm8mnp28jkih1cnb";
+      dzo = "1fcz0imi7zxi99762pxfcm5iz2jcbqj3s742magka4ihrxnz07xm";
+      ell = "0r0f71jy4y29bg055qvvy93wchi3lh08zz0k9c8l7466b03yvq5v";
+      eng = "0vghah8kqcv0n5fnjb88w6siz156ysrc41fckw3f2y8c3sgmqlf0";
+      enm = "10y61xv3w1ypgqz5rgb22y5hh1i4zx03cwiqw21ifqvg4xdrln46";
+      epo = "1y5lh55mbcx33cm7qlf1dcah8ffycxmlcpzjzx9r6ij14fdd4964";
+      equ = "1nqrd0a9jqqh6byy8snfhad1hisrc92dcx44wsy7v4nf40j3mx1s";
+      est = "12ll8lq1hjcsq9hh93020w78r7f1rcxcwlvrjqw8j5p3k9jg5a4g";
+      eus = "034s9mp7lw1a4yvf2cmbbj2fbqbaq6xnjqh30yn0wq0c0jck96nw";
+      fas = "0m61p4byc0kzf75cdn6g18s8hcg9r8ifs34wr85lbsb65kil4ijx";
+      fin = "1wac333k0lcd5jwprzg99b10bq8sdc96b9d6275kg9imyqjwcc7q";
+      fra = "1ax7i0nw1lwkz4sbrvn4z0lcrcai77ymdpla7qk7yij6s4xb5bw6";
+      frk = "16nmr71p93724vk1x5mq4r8vxpwnm448p6dwqv8scg8asch1cidp";
+      frm = "00yz3hz7wcralq8wbx1ap4c6b37ac6vnz5bgmxmgdx0kqzibiddn";
+      gle = "1n8z8kmn5m628rlzgz5v0iw6h46aalflq5asa1wj5rygx1y2azpa";
+      glg = "0fdniayplc3iwmlmvhblarh1gm97dp8rqhhkb8b0clwfd9cj342z";
+      grc = "04r2193qcxqyab5998xn8bf7197wiccmjm7iakij8d0c7l61dnxb";
+      guj = "0dp8mlxmf0x9wb8dg0c508sdwz03icq94z8ji8jhwgdqgv8hw1al";
+      hat = "0793mmlxbb09c8103jhdvlczz647nyn4ykkgd3gwgavncmjh72v8";
+      heb = "16za9ff1i3ya6hz75l9v3v7j4039kscxxw21g3i2w5p9zn52hyag";
+      hin = "1vnn5wpc724kgib8jbx0kpnnp4al60ivqir72gnbyh6cpnflb6bf";
+      hrv = "15rqd6xiv2bdmalb5s6rxvw0yk6w9agn9fli3bvi703q6vpj2yn3";
+      hun = "19zzwdxwi3h3vdsgr271i1m87gfpdirk6b1ljw2j8qmfilp4sw56";
+      iku = "1v1yvc1194qycjgb4ihh5hpj6472nlbp66dii183514g2dh9x0db";
+      ind = "120d4b41wvsgcd1sgy2mp78i9hvi7w03a63078dz1yds0yqdwf1p";
+      isl = "003ngk8dfv6dglkq8pmi6jsglrfkc65js5ywh3vvkg7qfqf6qsxz";
+      ita = "1lxklk3zc3x3k8yfpp6ygyv7fndgs57dfasc97rh8782ds16wkjs";
+      ita_old = "188gby1y51pa1ycyc8y17d16hs5w27yl5ch7xzni98bdjkwbkl1z";
+      jav = "1fjyjznjchls5ifbnx2b9xagisgxvgj9lsf39rr9d87sbzdbbwbp";
+      jpn = "1wmayj8wh3pfwznjhalad2qzv38mhrzw2sxl71mycvzvpdy9ag1w";
+      kan = "0hak4953whw9vd9dzl0hq076kzb19kk45kmfxk03af4k6gb206vg";
+      kat = "16k0057cvvdc6snm5svhdv3cr7cw71g74yy8215njjbsi838imi3";
+      kat_old = "02gl755d38plyvzwfjqxvjgfqkbjs9rvzx33qfhm2zvmgbwrfrfh";
+      kaz = "0hc36w7zz5waycsk220v0r83sg991gd5f5r937mvz44viql80sgm";
+      khm = "1gb2nv5qdq5fz9w9xq4fj68p46b62sd1m986ra5qbnskxqizr12s";
+      kir = "1b1ing6qqi8qqfh4xpk76rp4gxp69wdjdl5m777ayx3v02d7nhh3";
+      kor = "1rldj6f8h1nn5wpx57b0ci7p0fnivnwzgaf0d3576xls26z2wcgv";
+      kur = "1cp2pfd6g662gvxi7ywkxfbfq1lwbis888bf1gg8ynzy342mx1ic";
+      lao = "03bdaxakmxpbbr9vsnbzzfksvm6js0l5i0ijwl71piqyxqjj1gxf";
+      lat = "1q7v7drnwpna9k2l79jbdlxiv1j617rqzjc9d48h3lfrma5z97sj";
+      lav = "0fxzyvw7n67rmw2irvlghkf1bii4w47200zv26p0v3a9dwvhc7sg";
+      lit = "0f00ggjjqrl94kwwjmjqwajyfprsml0br8vhn2gvn11gaxvm52hm";
+      mal = "1i83plhin3m6sq8p92vzlyng5z59gvvqypyh7rnmvdmm9rranx8a";
+      mar = "0ay7q53yl3709crvn5l9c9jx7hw6m5d3x2crmvnvczsh83ayfdik";
+      mkd = "1q1wadcr4j1dzssyyqz43qmizc6vfqkbivr6xi2p7p4h9rl11x73";
+      mlt = "1qp4v6habak1l7xrw322wglvjjndrfp4j7bj8d4npwbzk1sh4s0h";
+      msa = "048p6mkx9zr40s9s5vbi0gnizhvqwn0g8i1hf1l8db7igbax5xyj";
+      mya = "17nyr5bd42kzvid3421n3mwckd49vzrjhjahd8rnfsmbsy1x382l";
+      nep = "154375r32sdmvcnp1ckvgbp3wxvb2xiiypb8bxbsvrabrz4wzjqc";
+      nld = "1clwbky71zkz55zd3f8r9hj8fhpnbkply80p1js4fvs7x12r715x";
+      nor = "1ynvrz6s0vmlq1xkjd8k2w6bx8770x6v29qgx83d4nl17ngjd459";
+      ori = "0dsakc8gnwhs6z5kxc2wdkbn31gkkiqk5vriw0swghychp164aac";
+      osd = "1zq0dfliavglmix7zzrqdxz1w01rm1f1x1352bqn8xf4zivdbxcw";
+      pan = "1fwdpwkydfmr6drwgkqzn89z12r2rdm02a75vvdxhxg2a9yiwmbv";
+      pol = "155z870ygzws476kp7qpzi8jcjcv3jb5px8rbzhnag1fklqr48hx";
+      por = "1814cff2rffpzlg4hyyrjzpf5ps2i95rmpa4c8ikblbvrlcv97q8";
+      pus = "1iz5nn1zfvn1l9gb1jriwx991d2hwwc7x4k1nvzjlwpzscplx25b";
+      ron = "11lr80zhvnnngvwwk01z1d3prfpbh3qbwpl1nl5fp7h09d6n3wzl";
+      rus = "1d6a8lg4bmd3np16jds1py3qpkaq4ahnhwghd5r0159y0jpxq00q";
+      san = "169f4ajgwn99yfdfrlwfvdgvv1abal7fpdp31sknvq8l7w2sak3g";
+      sin = "1411g18r6f6j6f4n0sn7ajgs4gkplb892s6ak0hi9nyyxwv3r1gm";
+      slk = "0bxfbrg1nf6px0xzkh6ihdi71fmr1rxxs99qb191k7pm16x2lpds";
+      slk_frak = "0zyqnn1y5cyx1y7wzgw743k4584ljl0rhvk2q1ni6jnjx9ciwzqy";
+      slv = "1kjn9m9hbwp0m0p2v8c3skpzr6f8x42hz8x48zl22550a7hq8n1h";
+      spa = "1npgl8ylvfm60hd4214z8a3lriy1hckhijschrbjpzmwdfcqafgj";
+      spa_old = "0w4ivkv8flyn7bjlyjcrcrdnslkvrrfs7l33mvird1jhhkyqd8sx";
+      sqi = "15wzvh6qm3yx7yf0k5j7g1imsaqxvq7r2xh6a0xgmkqbyypbbkdf";
+      srp = "05blqriv30x02c80ds3x7zhw0y21nc6lkqlv5jwgwnjgw4yfpgrm";
+      srp_latn = "0ss8s3q60aq8sd2a3sbnzvp13qqarxnjw4hij8hd9ab5gsjw0nwr";
+      swa = "1pwwhx7ldq21cv06cchws8gvwsmkwn5sjcy9z3nk3nbp9qjsf44f";
+      swe = "0l10iyn2cr7ibgk0akmpg8725mpwpydawgv3s77izsw7y6xhfr1a";
+      syr = "08bxil13wyp5h4hvbxjcys7ypgqgg46rrp653m7gyv5q94ycjgb0";
+      tam = "1g155kyba2wjfgzgy48g6yd2csinwbfjdi5r7vw0wm3dh1z39dvz";
+      tel = "0fydrcb54b6mmqazb337x4s36i2a64sb4xm7y7g3nqqmk9afsipv";
+      tgk = "0f6j37friywj7y132fv0jm6aj4sx8f0b7brspj3pbjqqpi4v5ws0";
+      tgl = "0f1r0gicif57qhyw8xaa1sqgny720q3z5cpd5srrn9i6fihaz577";
+      tha = "1y2hw55jfpidk95y8qbsiczgg2r2khabac97s1y3gl0v93a44jna";
+      tir = "1y7iryhjr83ca4yh5jjz7qlnrx4kbrp0a0p650whjvk2gnv8m98h";
+      tur = "0xqnq99b2jb4v74bj95py6wmg14dm31zp5s3l48dmcv6zdgcxg2w";
+      uig = "1sdddr15zlb33kd1d7hzi5lfd15bfhqn105d7x6snfpqp7vq4bxv";
+      ukr = "0cdwjnfnnmzz7jdn49l96vqgaimclfxcxaw09cm63f5my382r2rg";
+      urd = "10xcn1zs2lfswp5yai0ckyg7js587qhr5cf7qib3i35qjbw7nc18";
+      uzb = "1jkkd5j6vsx5jv5gwprbfwg1vwh714prm8j446wzvp74brmk949l";
+      uzb_cyrl = "1kdia38rgm2qd3ly80a412jyagxxryr09h1nz2d0iw71bmfn4855";
+      vie = "1ja18jxxaw282y4jljxpjf1gj15il61vc2ykpfy22vn88wvydxff";
+      yid = "1jddd0g8mm5v00z5kb8rbpfs7ppzgq9kzm1xlhhvv960yfdbi6fd";
+    };
+  };
+
+  v4 = makeLanguages {
+    tessdataRev = "4.0.0";
+    tessdata = "1chw1ya5zf8aaj2ixr9x013x7vwwwjjmx6f2ag0d6i14lypygy28";
+    all = "0dqgkp369rcvq72yhgnzj1pj8yrv7kqzc7y6sqs7nzcq7l5qazlg";
+
+    # Run `./fetch-language-hashes <tessdataRev>` to generate these hashes
+    languages = {
+      afr = "1a9f8pnrspfmcq9gpjnxn2kkhjlsmh912bnpx671fjizxpmiri2y";
+      amh = "0m1vdyxjx57kmf2qra0p31k509y1cqn4pyckzw00i5n3wx11d2j0";
+      ara = "0nswl6n0s94g900j5k1gwzp7m140c0yd9a2fdb2lzhdvg1krf190";
+      asm = "025d9vrjcrwyd6cc6hrw1x8xqhicgrb9wpvhhmlw71ql04dadslf";
+      aze = "01shcs78a6xn3my8p3y42x1c9f5hzfn83w2n2nwpffbgz4y2nsgf";
+      aze_cyrl = "1sbd89i5r7rnkjh2in8j0plrxnfiill9jl8pr68iw77ghih6q1vg";
+      bel = "0dhyymsxcyzwal8474q7ag3m2akv0b92hkdz7rka5z1cxry1cn8c";
+      ben = "0a7q9414k3frn37x2qcglz722ysg2iivj6kqaaa0ik7z14ibc8v0";
+      bod = "0rh7x54nlh6ir6ldccj8hi7g8hwlp13r3fkljw8gndvhwmgfkkar";
+      bos = "1szym4n605hlx12a9vpz4jjs76jscajh22rgkqwbv4qdsl0gi3nd";
+      bre = "070f4c84iznblsw4jkwpzh9dss8nfb678160szm5r8dlv2yinrrk";
+      bul = "03bg2yw79lg8rl43y9288313jrfh0h69vl4s4cmlgbmnbx8pvxwj";
+      cat = "19xs691aj8yy2ff07c3gzm07zicd5ha0gmcjxjh9pknqf2gfy7qv";
+      ceb = "1896vn41hqc4anm6hjvrnn022i0p8pmhwsp5rv9w2cvr6738l79r";
+      ces = "0fh2g47msfr91285rnccxcmcshihm126sqy496s4vrr0vk8ix1nf";
+      chi_sim = "0qxkvbpm5l7gzsshnn72wfx473pprf5nmw8hd4i4x2qxnfddh1gw";
+      chi_sim_vert = "1f75pzvxbda82vxa2zb1z9b9f13sh81kzaw45vg5118ncsklj8w7";
+      chi_tra = "056vjws1fir1v5iv44pzykkxs5q1dbb2j8blhj47i53w1zf6g42m";
+      chi_tra_vert = "10c9cdycg1a5kwlgg60sh8yp07w2fl4whinpxfhlzrzs56allql4";
+      chr = "19qq8a6c27973djsc4xpcklis92r58x21fg4mz5azdyka5i1n46l";
+      cos = "0z9kx1hw8h5n00pcahxla808wya50wrkk8cz7x676pd93ibyrlyx";
+      cym = "13pk9cpf43xxqbz3blfz2av2yd1ma6ds6jbdiqw8anhhj7l9ch2d";
+      dan = "1jirmahxvyyswhhyzhinvcqaycz7m3ixchqrj3lgfcdi3anvabr2";
+      dan_frak = "17wcgdqxmbzn7qchnx5gsa05aj4wmhbwk43w173bl3wr6h5ylmh0";
+      deu = "194rqsg4nlycca9bg2fqf15xgcl110rxp182l7dbjfjhar4knsw9";
+      deu_frak = "12hhhp32f15c7fw2jp05mwim9ps14kmamhh6vmalvm7r2033vbm7";
+      div = "09mm9r5hxhsc4qpyg10ym9mc2kdpawx8zk0aiv1xpgd35rzpyz41";
+      dzo = "1zk7crgcazgqy5zmslp6iw4jws07nja31qdxx0rpzhn3c0bjgw1b";
+      ell = "1hhym18a9411953j47xjk47jx9ij9xi2qwlx05c93zl41528nsqg";
+      eng = "0iy07z182lwhqfa0q288ha691scpsry330aynaizn68wcmywk86s";
+      enm = "1dhr1qvil38bil43wk5ci645sbm3my2y9y7qlcbnwz2p4pflayvm";
+      epo = "1jig4db7050vww32vxsqyig3j1b0vgz9ipxbsw0jpkjia84k44n9";
+      equ = "02qwg6s1z7pynwm0p6dvpwi04ivfkr1s7qgssbla1dx7v0ih6rlg";
+      est = "1jxygahy6by7fbirbmjmd68k6560q1a3h5mvpzdx15h5fw0q58gl";
+      eus = "0cai7nm7si8680avrrls8bf9ski980rvsj560fh9y6n9rz7mh9mp";
+      fao = "1n3434jf18bzakbylzyg3jaw2ad4h376g56dsql32bgh2yvyww8a";
+      fas = "17wjkfka9725rz32clgqgk9msmbz4axs59vz30jmhhxyrkliafqb";
+      fil = "0p713k8g27df9z384ns111xqxii5kq20m8brflsmd3yckw1mibhz";
+      fin = "1wc3y9nnm7rb2c2c5fkj7cv7jb27jlkb2bh0g8kaz57h6imfmb2g";
+      fra = "04qrfvi6irlaahh1pgn5azyfhbhavm12yyybza8603alf8firh7a";
+      frk = "05cqmxxxjqdl5hjyzi6dpmixnjpd6f3jr6741yapdmnxvkzxkiyp";
+      frm = "0a86yy6hd0lvlbzvnzjmyapzc0rn7mnkdadqycd65bw1b714cvy2";
+      fry = "0i84r8g9hlkr9nlhypl4lq6ncrhbcpskqkdcijgk88c2fdknh57h";
+      gla = "17idyhb505waz9dnb8dsk54faw7y0xvvb12yw71k0skq3i90akar";
+      gle = "1q87h5zzcva54pg364d3hl6q9hdlydlyj1qmq8n5k7hqk11msxmk";
+      glg = "01xssz1rhpy3a0sm4i43nba61wc2srz6wv327vdw1kg8ijm0s0g4";
+      grc = "00x0s3smx4wg5h12y2b9al0j2jk1y3f0yy2x6f2qf7ps831drgyl";
+      guj = "028v4fgn0zi2044vk6j2rlqklc9i0kj22s52vhifmx1g02kz9154";
+      hat = "1bca516pr2cnyjlwycc7pr6gfmdjb8565hp06pw9nwpr20ry0hss";
+      heb = "1qfkffjh29b21frs0mv6llsrchixl5kjkpj1if7fq816g9mym9kx";
+      hin = "1rkfam5c6qil2590lfffzndhq3bncdgf4ij0cyjcglgyljgx0xnc";
+      hrv = "0da7b6mk0rwc9zlbqkycwjpddp3qpy07l643i00ia5a1zq35fmgp";
+      hun = "0w2s4mn9p74zqzmp9hh2017zgsh5v43k4lid4pv29f4b0y5gj9xi";
+      hye = "0ifzm875wlbjh4vkpmj1n6f14m8i174413l6pc6i44y4p5fpgxrf";
+      iku = "19arnv82xbxhbcy8pf9fv1sl5zc5707mk34nh7w46dlz86qkidmn";
+      ind = "1d421hizwni4m6sr4f3nqqpr1g744hzn0krk130m7x8mhzgamba5";
+      isl = "1hjjw8k2r9qa990ziq5wxr36kyf16mnmrqfmq5vbcjprka9h08pq";
+      ita = "1qyrvlf7pjxzyb29sc7aq3gq61bww14sijka44scxggfw7134l3r";
+      ita_old = "1pf8461jbj0vpyry0b54crmkf2bk9mh4klxvmj09jvf0aq2vm9s6";
+      jav = "18vvbyimj0y462amjmwvqa6h9n8l122j9v0w3hfp63hlxpfprm0m";
+      jpn = "16hma9w32vdh41ihymp894jza72b0d235hwriv18r78j5n86nhbg";
+      jpn_vert = "0yca09l9sbpfjgb2slnpb9q7qd7vz3a1wb6bkln30d3nl0d9r1rn";
+      kan = "0lcmx37rjfxkbhhbrld1ndmkwkm9w9b3pzxhas0cv5dqsx2f84jd";
+      kat = "1b164bgwa7bbvw4177h8fxfh0fbh4bycfl9pkaa184dpjpaiqpia";
+      kat_old = "1mgff7sh93hdp3wh0ckikdggrdgf0syp75s39pickpbkp9ic41ai";
+      kaz = "0h37y0kb5lwsp5zpl7bvxg3ryqldl5hxfnardliwgyqgnag951vi";
+      khm = "0m7x1fynr18sid2kjjw8xa9ika0a0fc6a6hvc7ihizi47893hdfb";
+      kir = "09kxwqpqf6kxjii07qlqsiii83zk12rszp88xnzzjp8rjsnk78s3";
+      kor = "0nsr43fwrp9876ia1fc0zcviv2n8hw16n0wfh158vhygwglvy84m";
+      kor_vert = "1wmvdznmikk9fq7wdffvn22scxmcl26vjh26jhicqwxpc7kg4bh8";
+      kur = "0gbsf3ny3n5mgb30v54bz3crgnimdpg19jn633pbpzryzg3xhd25";
+      kur_ara = "1sbj0cczhi9q119fbzpi0m6zr9kjp3k76bv9w8szkv1wc5y4fng6";
+      lao = "1gvxlg8bw3a4c9izg3c2a2yl7q6rsy7z9y64axdw9a04pz2ndbl5";
+      lat = "0b7an3q3xrf9c55bhiqqh7l45ga88l0kwvkp1akmlr98piach3vr";
+      lav = "0fqsmy47cygamddxyjfrdgkfa9bvmrvf4csvppnkdvfzy6iiv0c2";
+      lit = "0wjgbkwc3bf5khdqali7ylnhhs4xvpx19m3zx2y9s27v2wjbb6kv";
+      ltz = "02zdxbniiqfl87fzsiaaqgldqfsv15z5hja1xhxnqpl0nds7shfc";
+      mal = "0a41ifz8i6lj2ywxjkwvymxzxahkz2cjv4apbrawdj1h42bn7frd";
+      mar = "00swhlh9bckvmlxanfmlw5j4n9qqhggl84bsq0827bmijsqwnl44";
+      mkd = "1bqfiwxlzfpz4fs4z5ci2wbv01qhrcayk1inmk3dxq7dsywx1ajg";
+      mlt = "1rmmga2aw88hr7q7cfr5cvhnsgnf1mi069d5k7z66zp4vzbl4zyz";
+      mon = "1jksvcavn9plsmjdmhg40mwq5rlvrd1b9gvghdjg7zkf6qqqynlh";
+      mri = "0jlfawx20s5clsnk82ndy3v2zidh4cfh4acrh8nindk21xmiwh5i";
+      msa = "0m7zs8anaa3l4z5f3xvbhs4syp41dp4all2yfpi1plyr0hy784an";
+      mya = "0hljm5haadlr4k5rhw4mvhkygcnrr709rvl7amz7av3nskmi8mb1";
+      nep = "1dhy0m2h6xfgwibf92iwxsn926dmrhfvkg9rafkdaqcr4pq6w563";
+      nld = "0bspf5bv1s7qzm6k4aqbpq91zvk4kxxhx5zv08w91xfsa1zpdxmi";
+      nor = "08majhc9m0fjvac50yq52ia2af9kscclimwkv403klnj4kgf8ndq";
+      oci = "1mzrw9gsdjrd1xj3zv7l5gzgjq5jrygxf8cfkz20d9lls0wj1xdv";
+      ori = "1sh42mjzb1hv6l6lljp3wifjmz7wrv818f9f16m8qjikwqxm0s78";
+      osd = "03mvfk1q1xp1klpf4bwna903rnp51bkqr3gl5hvxybvrc3l2m7z1";
+      pan = "0165kr94p6x5yxzs4p8sfppvg9cywp65ps0xaym5rqz9iashz32h";
+      pol = "0g0b71ms6ddgykmkna4mlavgzgmh9vj6s62fi8l4ja93nfpr37hp";
+      por = "132jbhzmcsq8skanm15bw2niyx9xpbrqr411wn7w9r5i3cvnlv01";
+      pus = "0iiglnkn478al11avigsav625pn7ifscycnxpj6fg8835vjww3xr";
+      que = "01vkmfi9idjwskv5pllmrxpil0v5h7f7rzv5viclxrzkmbvrz9b5";
+      ron = "0ag6vs0cn3sryavs1mfrallgdgi4h28114g7m61rhlhq0z484g0m";
+      rus = "1hippm3w5d73sh50r136x0xff2p6x128ry2x4fywf6xdpv1f46v8";
+      san = "1qlpqkr5c5wqcf1bvlipy72advqnvd4wm61vghmrj2sda8mx87sx";
+      sin = "097d2s4ma0zsq0ab5qs1ylgl9l5phw91fnpsvb7vjmz2mw3ic964";
+      slk = "0c97pp5iffhdzyma605x8q3rx1qq9pq2h6cai1kppaj92rz3ji9k";
+      slk_frak = "16ivsam1g18zlpw6pgidvzwb7h8rvw1s10nigs6yfwir8hjxsgki";
+      slv = "0644jlm55p0dg4zchgrashmbv36zb4x649ckmf2jkbss8bzx7wsf";
+      snd = "1i2mfi4414l3v9nznjy7959y2jcr8ymvf6w8zpyrw6nad4d1aak7";
+      spa = "15kwvr7cpcnlxm1ja1yyc022dmsd04gmk7h1p0df12aicsscn3qb";
+      spa_old = "1jq80c4mi3rmwnfhb3mbaaq0ci101mgbibkji9ala4l5dkcwjra3";
+      sqi = "19cvvixhz9906p4c9i2grpr386rbp5alp4fp14xm9nd81bmq4701";
+      srp = "1jd25n13h6vxsa3gzbj6q6mdh02rjl4qrd1bffr5psp33asqvw0l";
+      srp_latn = "1k7577mn3z0bm5ma9d8l14sn5wpvw50hq1nxwbc36yn3a5b3mhiz";
+      sun = "0lvlaw3jfvr7b5v09669kq8mm19jdsk9g5h09jsa2gr6fvsq11pa";
+      swa = "0qy9qc5pa1dzzqrh1z40gk845z1r4d2smywnzydknbb3n240lhz0";
+      swe = "1y56r7bgzw0pqkdylbah07r1f0v03sblkggiql8x5200rhaxvqi4";
+      syr = "1vfj5fsiv170jghryrxwyz0i9mdsaki1kglxrklkb2caal9kwy38";
+      tam = "0rhhdbnp0a2hpg00vpc0xyxcl2w36i1kn63mrvwx1f9q7m3y1fmf";
+      tat = "0a74rp8pyp4yivv2xcy2m8xgwch8scr3wmk1fzniwzf43fsrqp76";
+      tel = "0gcq8hxhxvilyh7x7kiikq07hllqysc8sfyr88gvpj4xi092h2bx";
+      tgk = "1458gk0k6gk49n8lr6fj7l7cwkhxn0lrhybzq10zl1ly7yzjhf67";
+      tgl = "12yscwckdy3l21mvsrj1021gxw2isjrg369r08rsf7lh96wn4wkn";
+      tha = "01f0j7gsc5slxaaql1gqbhk4wlwaxc29dlmfxwjzikxc46gjl0w8";
+      tir = "1q6w48b1jchv55713pq20inzjjdymh32fw8wxfaj1qi7bjqfb9fk";
+      ton = "06g60ga8rys8jaimqrvd4svh40qs1nz4bszdnf2hdv05ibryibdq";
+      tur = "0g9g1wvibp61qbriy8ys948yfkl88xk9g8f93bnq8w8dx029b6s8";
+      uig = "09sajx21lw3a3ph62dyqr10pjaq2mij10sdhkhvvjiydk34dn548";
+      ukr = "14q8ls8gkrg7c9pc6qzm6yf5ady3i3303vs1hz4d2idcl6yry334";
+      urd = "15vszhqraxqdcng1069p6i4xq3ck3904q207nkbap6dfpcpjig40";
+      uzb = "03hyw0vavmjirqs4wkd5r85g91w2avsyl14z624fhm3gc66pqg7n";
+      uzb_cyrl = "1433lrrp2lfgb1k0a4sc20b35b2jcl8f1z92vm2936y7w04xpaq7";
+      vie = "02k40d3wji74d1jgvkr3zrn9gpzlmp0lqhrrdmc48r2sgvnrnk8n";
+      yid = "0xnbvi04xv1qapqg72wa3bjwbw51pkdnyncjpjp37vn6dzh04l0z";
+      yor = "07w3aci52ng6i6nyp97q5zb2dqlj08w6im90y1h691qah1x44zlv";
+    };
+  };
+}

pkgs/applications/graphics/tesseract/tesseract3.nix

···
+{ stdenv, fetchurl, fetchFromGitHub, autoreconfHook, pkgconfig
+, leptonica, libpng, libtiff, icu, pango, opencl-headers }:
+
+stdenv.mkDerivation rec {
+  name = "tesseract-${version}";
+  version = "3.05.00";
+
+  src = fetchFromGitHub {
+    owner = "tesseract-ocr";
+    repo = "tesseract";
+    rev = version;
+    sha256 = "11wrpcfl118wxsv2c3w2scznwb48c4547qml42s2bpdz079g8y30";
+  };
+
+  enableParallelBuilding = true;
+
+  nativeBuildInputs = [ pkgconfig autoreconfHook ];
+  buildInputs = [ leptonica libpng libtiff icu pango opencl-headers ];
+
+  LIBLEPT_HEADERSDIR = "${leptonica}/include";
+
+  meta = {
+    description = "OCR engine";
+    homepage = https://github.com/tesseract-ocr/tesseract;
+    license = stdenv.lib.licenses.asl20;
+    maintainers = with stdenv.lib.maintainers; [ viric earvstedt ];
+    platforms = with stdenv.lib.platforms; linux ++ darwin;
+  };
+}

pkgs/applications/graphics/tesseract/tesseract4.nix

···
+{ stdenv, fetchFromGitHub, autoreconfHook, autoconf-archive, pkgconfig
+, leptonica, libpng, libtiff, icu, pango, opencl-headers }:
+
+stdenv.mkDerivation rec {
+  name = "tesseract-${version}";
+  version = "4.0.0";
+
+  src = fetchFromGitHub {
+    owner = "tesseract-ocr";
+    repo = "tesseract";
+    rev = version;
+    sha256 = "1b5fi2vibc4kk9b30kkk4ais4bw8fbbv24bzr5709194hb81cav8";
+  };
+
+  enableParallelBuilding = true;
+
+  nativeBuildInputs = [ pkgconfig autoreconfHook autoconf-archive ];
+  buildInputs = [ leptonica libpng libtiff icu pango opencl-headers ];
+
+  meta = {
+    description = "OCR engine";
+    homepage = https://github.com/tesseract-ocr/tesseract;
+    license = stdenv.lib.licenses.asl20;
+    maintainers = with stdenv.lib.maintainers; [ viric earvstedt ];
+    platforms = with stdenv.lib.platforms; linux ++ darwin;
+  };
+}

pkgs/applications/graphics/tesseract/wrapper.nix

···
+{ stdenv, makeWrapper, tesseractBase, languages
+
+# A list of languages like [ "eng" "spa" … ] or `null` for all available languages
+, enableLanguages ? null
+
+# A list of files or a directory containing files
+, tessdata ? (if enableLanguages == null then languages.all
+              else map (lang: languages.${lang}) enableLanguages)
+
+# This argument is obsolete
+, enableLanguagesHash ? null
+}:
+
+let
+  passthru = { inherit tesseractBase languages tessdata; };
+
+  tesseractWithData = tesseractBase.overrideAttrs (_: {
+    inherit tesseractBase tessdata;
+
+    buildInputs = [ makeWrapper ];
+
+    buildCommand = ''
+      makeWrapper {$tesseractBase,$out}/bin/tesseract --set-default TESSDATA_PREFIX $out/share/tessdata
+
+      # Recursively link include, share
+      cp -rs --no-preserve=mode $tesseractBase/{include,share} $out
+
+      cp -r --no-preserve=mode $tesseractBase/lib $out
+      # Fixup the store paths in lib so that the tessdata from this derivation is used.
+      if (( ''${#tesseractBase} != ''${#out} )); then
+        echo "Can't replace store paths due to differing lengths"
+        exit 1
+      fi
+      find $out/lib -type f -exec sed -i "s|$tesseractBase|$out|g" {} \;
+
+      if [[ -d "$tessdata" ]]; then
+        ln -s $tessdata/* $out/share/tessdata
+      else
+        for lang in $tessdata; do
+          ln -s $lang $out/share/tessdata/''${lang#/nix/store*-}
+        done
+      fi
+
+      if [[ ! -e $out/share/tessdata/eng.traineddata ]]; then
+         # This is a bug in Tesseract's internal tessdata discovery mechanism
+         echo "eng.traineddata must be present in tessdata for Tesseract to work"
+         exit 1
+      fi
+    '';
+  });
+
+  tesseract = (if enableLanguages == [] then tesseractBase else tesseractWithData) // passthru;
+in
+  if enableLanguagesHash == null then
+    tesseract
+  else
+    stdenv.lib.warn "Argument `enableLanguagesHash` is obsolete and can be removed."
+    tesseract

pkgs/applications/misc/albert/default.nix

···
 { mkDerivation, lib, fetchFromGitHub, makeWrapper, qtbase,
-  qtdeclarative, qtsvg, qtx11extras, muparser, cmake, python3 }:
+  qtdeclarative, qtsvg, qtx11extras, muparser, cmake, python3,
+  qtcharts }:
 
-let
-  pname = "albert";
-  version = "0.14.22";
-in
 mkDerivation rec {
-  name = "${pname}-${version}";
+  pname = "albert";
+  version = "0.15.0";
 
   src = fetchFromGitHub {
     owner  = "albertlauncher";
     repo   = "albert";
     rev    = "v${version}";
-    sha256 = "0i9kss5szirmd0pzw3cm692kl9rhkan1zfywfqrjdf3i3b6914sg";
+    sha256 = "063z9yq6bsxcsqsw1n93ks5dzhzv6i252mjz1d5mxhxvgmqlfk0v";
     fetchSubmodules = true;
   };
 
   nativeBuildInputs = [ cmake makeWrapper ];
 
-  buildInputs = [ qtbase qtdeclarative qtsvg qtx11extras muparser python3 ];
+  buildInputs = [ qtbase qtdeclarative qtsvg qtx11extras muparser python3 qtcharts ];
 
   enableParallelBuilding = true;
 

pkgs/applications/misc/flrig/default.nix

···
 }:
 
 stdenv.mkDerivation rec {
-  version = "1.3.40";
+  version = "1.3.41";
   pname = "flrig";
   name = "${pname}-${version}";
 
   src = fetchurl {
     url = "mirror://sourceforge/fldigi/${name}.tar.gz";
-    sha256 = "1wr7bb2577gha7y3a8m5w60m4xdv8m0199cj2c6349sgbds373w9";
+    sha256 = "0vh14azg3pppyg3fb7kf6q3ighw1ka9m60jf2dzsd77f4hidhqx4";
   };
 
   buildInputs = [

pkgs/applications/misc/glom/default.nix

···
+{ stdenv
+, fetchFromGitLab
+, pkgconfig
+, autoconf
+, automake
+, libtool
+, mm-common
+, intltool
+, itstool
+, doxygen
+, graphviz
+, makeFontsConf
+, freefont_ttf
+, boost
+, libxmlxx3
+, libxslt
+, libgdamm
+, libarchive
+, libepc
+, python3
+, ncurses
+, glibmm
+, gtk3
+, openssl
+, gtkmm3
+, goocanvasmm2
+, evince
+, isocodes
+, gtksourceviewmm4
+, postgresql
+, gnome3
+, gobject-introspection
+, wrapGAppsHook
+}:
+
+let
+  gda = libgdamm.override {
+    mysqlSupport = true;
+    postgresSupport = true;
+  };
+  python = python3.withPackages (pkgs: with pkgs; [ pygobject3 ]);
+  sphinx-build = python3.pkgs.sphinx.overrideAttrs (super: {
+    postFixup = super.postFixup or "" + ''
+      # Do not propagate Python
+      rm $out/nix-support/propagated-build-inputs
+    '';
+  });
+  boost_python = boost.override { enablePython = true; inherit python; };
+in stdenv.mkDerivation rec {
+  pname = "glom";
+  version = "unstable-2018-12-16";
+
+  outputs = [ "out" "lib" "dev" "doc" "devdoc" ];
+
+  src = fetchFromGitLab {
+    domain = "gitlab.gnome.org";
+    owner = "GNOME";
+    repo = pname;
+    rev = "fa5ff04f209f35bf3e97bc1c3eb1d1138d6172ce";
+    sha256 = "145hnk96xa4v35i3a3mbf3fnx4nlk8cksc0qhm7nrh8cnnrbdfgn";
+  };
+
+  nativeBuildInputs = [
+    pkgconfig
+    autoconf
+    automake
+    libtool
+    mm-common
+    intltool
+    gnome3.yelp-tools
+    itstool
+    doxygen
+    graphviz
+    sphinx-build
+    wrapGAppsHook
+    gobject-introspection # for setup hook
+  ];
+
+  buildInputs = [
+    boost_python
+    glibmm
+    gtk3
+    openssl
+    libxmlxx3
+    libxslt
+    gda
+    libarchive
+    libepc
+    python
+    ncurses # for python
+    gtkmm3
+    goocanvasmm2
+    evince
+    isocodes
+    python3.pkgs.pygobject3
+    gtksourceviewmm4
+    postgresql # for pg_config
+  ];
+
+  enableParallelBuilding = true;
+
+  preConfigure = "NOCONFIGURE=1 ./autogen.sh";
+
+  configureFlags = [
+    "--with-boost-python=boost_python${stdenv.lib.versions.major python3.version}${stdenv.lib.versions.minor python3.version}"
+  ];
+
+  makeFlags = [
+    "libdocdir=${placeholder "doc"}/share/doc/$(book_name)"
+    "devhelpdir=${placeholder "devdoc"}/share/devhelp/books/$(book_name)"
+  ];
+
+  # Fontconfig error: Cannot load default config file
+  FONTCONFIG_FILE = makeFontsConf {
+    fontDirectories = [ freefont_ttf ];
+  };
+
+  preFixup = ''
+    gappsWrapperArgs+=(
+      --prefix PYTHONPATH : "${placeholder "out"}/${python3.sitePackages}"
+      --set PYTHONHOME "${python}"
+    )
+  '';
+
+  meta = with stdenv.lib; {
+    description = "An easy-to-use database designer and user interface";
+    homepage = http://www.glom.org/;
+    license = [ licenses.lgpl2 licenses.gpl2 ];
+    maintainers = gnome3.maintainers;
+    platforms = platforms.linux;
+  };
+}

pkgs/applications/misc/k2pdfopt/default.nix

···
         cp ${src}/leptonica_mod/* src/
       '';
     });
-    tesseract_modded = tesseract.overrideAttrs (attrs: {
-      prePatch = ''
-        cp ${src}/tesseract_mod/{ambigs.cpp,ccutil.h,ccutil.cpp} ccutil/
-        cp ${src}/tesseract_mod/dawg.cpp api/
-        cp ${src}/tesseract_mod/{imagedata.cpp,tessdatamanager.cpp} ccstruct/
-        cp ${src}/tesseract_mod/openclwrapper.h opencl/
-        cp ${src}/tesseract_mod/{tessedit.cpp,thresholder.cpp} ccmain/
-        cp ${src}/tesseract_mod/tess_lang_mod_edge.h cube/
-        cp ${src}/tesseract_mod/tesscapi.cpp api/
-        cp ${src}/include_mod/{tesseract.h,leptonica.h} api/
-      '';
-      patches = [ ./tesseract.patch ];
-    });
+    tesseract_modded = tesseract.override {
+      tesseractBase = tesseract.tesseractBase.overrideAttrs (_: {
+        prePatch = ''
+          cp ${src}/tesseract_mod/{ambigs.cpp,ccutil.h,ccutil.cpp} ccutil/
+          cp ${src}/tesseract_mod/dawg.cpp api/
+          cp ${src}/tesseract_mod/{imagedata.cpp,tessdatamanager.cpp} ccstruct/
+          cp ${src}/tesseract_mod/openclwrapper.h opencl/
+          cp ${src}/tesseract_mod/{tessedit.cpp,thresholder.cpp} ccmain/
+          cp ${src}/tesseract_mod/tess_lang_mod_edge.h cube/
+          cp ${src}/tesseract_mod/tesscapi.cpp api/
+          cp ${src}/include_mod/{tesseract.h,leptonica.h} api/
+        '';
+        patches = [ ./tesseract.patch ];
+      });
+    };
   in
     [ zlib libpng ] ++
     optional enableGSL gsl ++

pkgs/applications/misc/llpp/default.nix

···
-{ stdenv, lib, makeWrapper, fetchgit, pkgconfig, ninja, ocaml, findlib, mupdf
-, gtk3, openjpeg, jbig2dec, mujs, xsel, openssl, freetype, ncurses }:
+{ stdenv, lib, substituteAll, makeWrapper, fetchgit, ocaml, mupdf, libX11,
+libGLU_combined, freetype, xclip }:
 
-assert lib.versionAtLeast (lib.getVersion ocaml) "4.02";
+assert lib.versionAtLeast (lib.getVersion ocaml) "4.07";
 
 stdenv.mkDerivation rec {
   name = "llpp-${version}";
-  version = "2018-03-02";
+  version = "30";
 
   src = fetchgit {
     url = "git://repo.or.cz/llpp.git";
-    rev = "0ab1fbbf142b6df6d6bae782e3af2ec50f32dec9";
-    sha256 = "1h0hrmxwm7ripgp051788p8ad0q38dc9nvjx87mdwlkwk9qc0dis";
+    rev = "v${version}";
+    sha256 = "0iilpzf12hs0zky58j55l4y5dvzv7fc53nsrg324n9vka92mppvd";
     fetchSubmodules = false;
   };
 
-  nativeBuildInputs = [ pkgconfig makeWrapper ninja ];
-  buildInputs = [ ocaml findlib mupdf gtk3 jbig2dec openjpeg mujs openssl freetype ncurses ];
+  patches = (substituteAll {
+    inherit version;
+    src = ./fix-build-bash.patch;
+  });
+
+  nativeBuildInputs = [ makeWrapper ];
+  buildInputs = [ ocaml mupdf libX11 libGLU_combined freetype ];
 
   dontStrip = true;
 
   configurePhase = ''
-    sed -i -e 's+ocamlc --version+ocamlc -version+' build.sh
-    sed -i -e 's+-I \$srcdir/mupdf/include -I \$srcdir/mupdf/thirdparty/freetype/include+-I ${freetype.dev}/include+' build.sh
-    sed -i -e 's+-lmupdf +-lfreetype -lz -lharfbuzz -ljbig2dec -lopenjp2 -ljpeg -lmupdf +' build.sh
-    sed -i -e 's+-L\$srcdir/mupdf/build/native ++' build.sh
+    mkdir -p build/mupdf/thirdparty
+    ln -s ${freetype.dev} build/mupdf/thirdparty/freetype
   '';
 
   buildPhase = ''
-    sh ./build.sh build
+    bash ./build.bash build
   '';
 
   installPhase = ''
···
     install build/llpp $out/bin
     wrapProgram $out/bin/llpp \
         --prefix CAML_LD_LIBRARY_PATH ":" "$out/lib" \
-        --prefix PATH ":" "${xsel}/bin"
+        --prefix PATH ":" "${xclip}/bin"
   '';
 
   meta = with stdenv.lib; {
     homepage = https://repo.or.cz/w/llpp.git;
     description = "A MuPDF based PDF pager written in OCaml";
     platforms = platforms.linux;
-    maintainers = with maintainers; [ pSub ];
+    maintainers = with maintainers; [ pSub enzime ];
     license = licenses.gpl3;
   };
 }

pkgs/applications/misc/llpp/fix-build-bash.patch

···
+From cccadedfbcb6764a38382154838113a6b2fd4dee Mon Sep 17 00:00:00 2001
+From: Michael Hoang <[e-mail]>
+Date: Mon, 10 Dec 2018 15:08:01 +1100
+Subject: [PATCH] Patch build.bash for nixpkgs
+
+---
+ build.bash | 37 ++-----------------------------------
+ 1 file changed, 2 insertions(+), 35 deletions(-)
+
+diff --git a/build.bash b/build.bash
+index 1588011..72117d9 100755
+--- a/build.bash
++++ b/build.bash
+@@ -29,7 +29,6 @@ srcd="$(dirname $0)"
+ mudir=$outd/mupdf
+ muinc="-I $mudir/include -I $mudir/thirdparty/freetype/include"
+ 
+-test -d "$mudir" || die muPDF not found, consult $(dirname $0)/BUILDING
+ 
+ mkdir -p $outd/{$wsid,lablGL}
+ :>$outd/ordered
+@@ -39,12 +38,6 @@ isfresh() { test -r "$1.past" && . "$1.past" && test "$k" = "$2"; }
+ mbt=native
+ mulibs="$mudir/build/$mbt/libmupdf.a" # $mudir/build/$mbt/libmupdf-third.a
+ 
+-keycmd="(cd $mudir && git describe --tags --dirty); digest $mulibs"
+-isfresh "$mulibs" "$(eval $keycmd)" || (
+-    make -C "$mudir" build=$mbt -j $mjobs libs
+-    echo "k='$(eval $keycmd)'" >$mudir/build/$mbt/libmupdf.a.past
+-) && vecho "fresh mupdf"
+-
+ oincs() {
+     local i=
+     local incs1=
+@@ -90,32 +83,6 @@ mflags() {
+ }
+ 
+ overs="$(ocamlc -vnum 2>/dev/null)" || overs=""
+-test "$overs" = "4.07.0" || {
+-    url=https://caml.inria.fr/pub/distrib/ocaml-4.07/ocaml-4.07.0.tar.xz
+-    txz=$outd/$(basename $url)
+-    isfresh $txz $url || {
+-        executable_p() { command -v "$1" >/dev/null 2>&1; }
+-        if executable_p wget; then dl() { wget -q "$1" -O "$2"; }
+-        elif executable_p curl; then dl() { curl -L "$1" -o "$2"; }
+-        else die "no program to fetch remote urls found"
+-        fi
+-        dl $url $txz
+-        echo "k=$url" >$txz.past
+-    } && vecho "fresh $txz"
+-    absprefix=$(cd $outd &>/dev/null; pwd -P)
+-    export PATH=$absprefix/bin:$PATH
+-    isfresh $absprefix/bin/ocamlc "$url" || (
+-        tar xf $txz -C $outd
+-        bn=$(basename $url)
+-        cd $outd/${bn%.tar.xz}
+-        ./configure -prefix $absprefix                                      \
+-                    -no-graph -no-debugger -no-ocamldoc -no-native-compiler
+-        make -j $mjobs world
+-        make install
+-        echo "k='$url'" >$absprefix/bin/ocamlc.past
+-    ) && vecho "fresh ocamlc"
+-    overs=$(ocamlc -vnum 2>/dev/null)
+-}
+ 
+ bocaml1() {
+     grep -q "$3" $outd/ordered || {
+@@ -224,7 +191,7 @@ bobjc() {
+     } && vecho "fresh $o"
+ }
+ 
+-ver=$(cd $srcd && git describe --tags --dirty) || ver=unknown
++ver=@version@
+ 
+ cmd="(. $srcd/genconfstr.sh >$outd/confstruct.ml)"
+ keycmd="digest $srcd/genconfstr.sh $outd/confstruct.ml"
+@@ -278,7 +245,7 @@ for m in ml_gl ml_glarray ml_raw; do
+ done
+ 
+ libs="str.cma unix.cma"
+-clibs="-L$mudir/build/$mbt -lmupdf -lmupdf-third -lpthread"
++clibs="-lmupdf -lfreetype -lpthread"
+ if $darwin; then
+     mcomp=$(ocamlc -config | grep bytecomp_c_co | { read _ c; echo $c; })
+     clibs="$clibs -framework Cocoa -framework OpenGL"
+-- 
+2.19.2
+

pkgs/applications/misc/pgmanage/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "pgmanage-${version}";
-  version = "10.3.1";
+  version = "11.0.1";
 
   src = fetchFromGitHub {
     owner  = "pgManage";
     repo   = "pgManage";
     rev    = "v${version}";
-    sha256 = "0ym1arla9wfkmr5n6h6dfyd680vlnng5s5j5nyxi2gl2wxqqhxzz";
+    sha256 = "1a1dbc32b3y0ph8ydf800h6pz7dg6g1gxgid4gffk7k58xj0c5yf";
   };
 
   patchPhase = ''

pkgs/applications/misc/playonlinux/default.nix

···
 }:
 
 let
-  version = "4.2.12";
+  version = "4.3.3";
 
   binpath = stdenv.lib.makeBinPath
     [ cabextract
···
 
   src = fetchurl {
     url = "https://www.playonlinux.com/script_files/PlayOnLinux/${version}/PlayOnLinux_${version}.tar.gz";
-    sha256 = "03k8v9dknc5hfrfzqw1nkpifz7wkixv3mvjl1vnp4fx8rj2xrjrq";
+    sha256 = "117xivwa87i2w66klplmwd5q7pfxcbrj2rjm11wl8iy5h3xpqkak";
   };
 
   nativeBuildInputs = [ makeWrapper ];

pkgs/applications/misc/qmapshack/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "qmapshack-${version}";
-  version = "1.12.0";
+  version = "1.12.1";
 
   src = fetchurl {
     url = "https://bitbucket.org/maproom/qmapshack/downloads/${name}.tar.gz";
-    sha256 = "0d5p60kq9pa2hfql4nr8p42n88lr42jrsryrsllvaj45b8b6kvih";
+    sha256 = "1d6n7xk0ksxb1fw43s5lb08vgxf6h93k3rb401cbka1inpyf2232";
   };
 
   nativeBuildInputs = [ cmake ];

pkgs/applications/misc/soapysdr/default.nix

···
   };
 
   nativeBuildInputs = [ cmake pkgconfig ];
-  buildInputs = [ libusb ncurses numpy swig2 python ];
+  buildInputs = [ libusb ncurses numpy swig2 python makeWrapper ];
 
   cmakeFlags = [
     "-DCMAKE_BUILD_TYPE=Release"
···
     done
 
     # Needed for at least the remote plugin server
-    for file in out/bin/*; do
-        ${makeWrapper}/bin/wrapProgram "$file" \
+    for file in $out/bin/*; do
+        wrapProgram "$file" \
             --prefix SOAPY_SDR_PLUGIN_PATH : ${lib.makeSearchPath "lib/SoapySDR/modules0.6" extraPackages}
     done
   '';

pkgs/applications/networking/browsers/chromium/upstream-info.nix

···
 # This file is autogenerated from update.sh in the same directory.
 {
   beta = {
-    sha256 = "03ddfxxzh8pxil9n28y8nkzl8x0kb5bzzjy4mihg448dflh3anq2";
-    sha256bin64 = "147lh1way8db0j0m6wbpfzmfsvvlsjb29cjgf7s9hljb00wqv6ay";
-    version = "71.0.3578.80";
+    sha256 = "1xcdbf5yia3xm0kil0gyd1mlj3m902w1px3lzpdqv31mr2lzaz08";
+    sha256bin64 = "0pcbz3201nyl07psdxwphb3z9shqj4crj16f97xclyvjnwpl1jnp";
+    version = "72.0.3626.28";
   };
   dev = {
-    sha256 = "0whw1kq5gd07k061ycfdn7bygahbl6zqa54wkz2lqh73yknbbnj4";
-    sha256bin64 = "0hlfzzf7kx90jw0zin685c4haiv262hf9a4sj6fmb2yhj21hbp87";
-    version = "72.0.3622.0";
+    sha256 = "1vlpcafg3xx6bpnf74xs6ifqjbpb5bpxp10r55w4784yr57pmhq3";
+    sha256bin64 = "02y974zbxy1gbiv9q8hp7nfl0l5frn35ggmgc44g90pbry48h8rg";
+    version = "73.0.3642.0";
   };
   stable = {
-    sha256 = "03ddfxxzh8pxil9n28y8nkzl8x0kb5bzzjy4mihg448dflh3anq2";
-    sha256bin64 = "1rnw3whn2aaxxb4w3s2nf0wb91qjrq099550j42wig7xa71j6rz4";
-    version = "71.0.3578.80";
+    sha256 = "0icxdg4fvz30jzq0xvl11zlwc9anb3lr9lb8sn1lqxr513isjmhw";
+    sha256bin64 = "07kiqx5bpk54il0ynxl61bs5yscxb470q2bw3sx6cxjbhmnvbcn2";
+    version = "71.0.3578.98";
   };
 }

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

···
-{ stdenv, fetchurl, cmake, pkgconfig, intltool, vala_0_34, wrapGAppsHook
-, gtk3, webkitgtk, librsvg, libnotify, sqlite
-, glib-networking, gsettings-desktop-schemas, libsoup, pcre, gnome3
-, libxcb, libpthreadstubs, libXdmcp, libxkbcommon, epoxy, at-spi2-core
-, zeitgeistSupport ? false, zeitgeist ? null
+{ stdenv, fetchurl, cmake, ninja, pkgconfig, intltool, vala, wrapGAppsHook
+, gtk3, webkitgtk, sqlite, gsettings-desktop-schemas, libsoup, glib-networking, gnome3
 }:
 
-assert zeitgeistSupport -> zeitgeist != null;
-
 stdenv.mkDerivation rec {
-  name = "midori-${version}";
-  version = "0.5.11";
-
-  meta = with stdenv.lib; {
-    description = "Lightweight WebKitGTK+ web browser";
-    homepage = http://midori-browser.org;
-    license = with licenses; [ lgpl21Plus ];
-    platforms = with platforms; linux;
-    maintainers = with maintainers; [ raskin ramkromberg ];
-  };
+  pname = "midori";
+  version = "7";
 
   src = fetchurl {
-    urls = [
-      "${meta.homepage}/downloads/midori_${version}_all_.tar.bz2"
-      "http://mirrors-ru.go-parts.com/blfs/conglomeration/midori/midori_${version}_all_.tar.bz2"
-    ];
-    name = "midori_${version}_all_.tar.bz2";
-    sha256 = "0gcwqkcyliqz10i33ww3wl02mmfnl7jzl2d493l4l53ipsb1l6cn";
+    url = "https://github.com/midori-browser/core/releases/download/v${version}/midori-v${version}.0.tar.gz";
+    sha256 = "0ffdnjp55s0ci737vlhxikb2nihghwlb6mjcjzpgpnzi47vjqnwh";
   };
 
   nativeBuildInputs = [
-    pkgconfig wrapGAppsHook cmake intltool vala_0_34
+    pkgconfig cmake ninja intltool vala wrapGAppsHook
   ];
 
   buildInputs = [
-    gtk3 webkitgtk librsvg libnotify sqlite gsettings-desktop-schemas pcre gnome3.gcr
-    libxcb libpthreadstubs libXdmcp libxkbcommon epoxy at-spi2-core
-    (libsoup.override {gnomeSupport = true;})
-  ] ++ stdenv.lib.optionals zeitgeistSupport [
-    zeitgeist
-  ];
-
-  cmakeFlags = [
-    "-DUSE_ZEITGEIST=${if zeitgeistSupport then "ON" else "OFF"}"
-    "-DHALF_BRO_INCOM_WEBKIT2=ON"
-    "-DUSE_GTK3=1"
+    gtk3 webkitgtk sqlite gsettings-desktop-schemas gnome3.gcr
+    (libsoup.override { gnomeSupport = true; }) gnome3.libpeas
+    glib-networking
   ];
 
-  NIX_LDFLAGS="-lX11";
-
-  preFixup = ''
-    gappsWrapperArgs+=(--prefix XDG_DATA_DIRS : "$GSETTINGS_SCHEMAS_PATH" --prefix GIO_EXTRA_MODULES : "${glib-networking.out}/lib/gio/modules")
-  '';
+  meta = with stdenv.lib; {
+    description = "Lightweight WebKitGTK+ web browser";
+    homepage = https://www.midori-browser.org/;
+    license = with licenses; [ lgpl21Plus ];
+    platforms = with platforms; linux;
+    maintainers = with maintainers; [ raskin ramkromberg ];
+  };
 }

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

···
 assert withMediaPlayback -> gst_all_1 != null;
 
 let
-  pdfjs = stdenv.mkDerivation rec {
-    name = "pdfjs-${version}";
+  pdfjs = let
     version = "1.10.100";
-
-    src = fetchzip {
-      url = "https://github.com/mozilla/pdf.js/releases/download/${version}/${name}-dist.zip";
-      sha256 = "04df4cf6i6chnggfjn6m1z9vb89f01a0l9fj5rk21yr9iirq9rkq";
-      stripRoot = false;
-    };
-
-    buildCommand = ''
-      mkdir $out
-      cp -r $src $out
-    '';
+  in
+  fetchzip rec {
+    name = "pdfjs-${version}";
+    url = "https://github.com/mozilla/pdf.js/releases/download/v${version}/${name}-dist.zip";
+    sha256 = "04df4cf6i6chnggfjn6m1z9vb89f01a0l9fj5rk21yr9iirq9rkq";
+    stripRoot = false;
   };
 
 in python3Packages.buildPythonApplication rec {

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

···
 
   inherit patches;
 
-  installFlags = [ "PREFIX=/" "DESTDIR=$(out)" ];
+  installFlags = [ "PREFIX=$(out)" ];
 
   meta = with stdenv.lib; {
     description = "A simple web browser based on WebKit/GTK+";

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

···
-{ stdenv, fetchFromGitHub, go, removeReferencesTo }:
+{ stdenv, fetchFromGitHub, buildGoPackage }:
 
-stdenv.mkDerivation rec {
+buildGoPackage rec {
   name = "cni-${version}";
   version = "0.6.0";
 
···
     sha256 = "00ajs2r5r2z3l0vqwxrcwhjfc9px12qbcv5vnvs2mdipvvls1y2y";
   };
 
-  buildInputs = [ removeReferencesTo go ];
-
-  GOCACHE = "off";
+  goPackagePath = "github.com/containernetworking/cni";
 
   buildPhase = ''
+    cd "go/src/${goPackagePath}"
     patchShebangs build.sh
     ./build.sh
   '';
 
   installPhase = ''
-    mkdir -p $out/bin
-    mv bin/cnitool $out/bin
-  '';
-
-  preFixup = ''
-    find $out/bin -type f -exec remove-references-to -t ${go} '{}' +
+    install -Dm555 bin/cnitool $bin/bin/cnitool
   '';
 
   meta = with stdenv.lib; {
     description = "Container Network Interface - networking for Linux containers";
     license = licenses.asl20;
     homepage = https://github.com/containernetworking/cni;
-    maintainers = with maintainers; [offline];
+    maintainers = with maintainers; [ offline vdemeester ];
     platforms = [ "x86_64-linux" ];
   };
 }

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

···
   # Requires tox, hadoop, and google cloud
   doCheck = false;
 
+  # This enables accessing modules stored in cwd
+  makeWrapperArgs = ["--prefix PYTHONPATH . :"];
+
   meta = with lib; {
     homepage = https://github.com/spotify/luigi;
     description = "Python package that helps you build complex pipelines of batch jobs";

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

···
 
 stdenv.mkDerivation rec {
 
-  name = "pig-0.16.0";
+  name = "pig-0.17.0";
 
   src = fetchurl {
     url = "mirror://apache/pig/${name}/${name}.tar.gz";
-    sha256 = "0p79grz5islnq195lv7pqdxb5l3v4y0k0w63602827qs70zpr508";
+    sha256 = "1wwpg0w47f49rnivn2d26vrxgyfl9gpqx3vmzbl5lhx6x5l3fqbd";
 
   };
 
-  buildInputs = [ makeWrapper ];
+  nativeBuildInputs = [ makeWrapper ];
 
   installPhase = ''
     mkdir -p $out
···
   '';
 
   meta = with stdenv.lib; {
-    homepage = http://pig.apache.org/;
+    homepage = https://pig.apache.org/;
     description = "High-level language for Apache Hadoop";
     license = licenses.asl20;
 

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

···
 
 buildGoPackage rec {
   name = "terragrunt-${version}";
-  version = "0.17.3";
+  version = "0.17.4";
 
   goPackagePath = "github.com/gruntwork-io/terragrunt";
 
···
     owner  = "gruntwork-io";
     repo   = "terragrunt";
     rev    = "v${version}";
-    sha256 = "1b0fwql9nr00qpvcbsbdymxf1wrgr590gkms7yz3yirb4xfl3gl3";
+    sha256 = "13hlv0ydmv8gpzgg6bfr7rp89xfw1bkgd0j684armw8zq29cmv3a";
   };
 
   goDeps = ./deps.nix;

pkgs/applications/networking/flexget/default.nix

···
-{ lib, python
-, delugeSupport ? true, deluge ? null
-}:
-
-assert delugeSupport -> deluge != null;
+{ lib, python36 }:
 
 # Flexget have been a trouble maker in the past,
 # if you see flexget breaking when updating packages, don't worry.
···
 # -- Mic92
 
 let
-  python' = python.override { inherit packageOverrides; };
+  python' = python36.override { inherit packageOverrides; };
 
   packageOverrides = self: super: {
-    sqlalchemy = super.sqlalchemy.overridePythonAttrs (old: rec {
-      version = "1.2.6";
-      src = old.src.override {
-        inherit version;
-        sha256 = "1nwylglh256mbwwnng6n6bzgxshyz18j12hw76sghbprp74hrc3w";
-      };
-    });
-
     guessit = super.guessit.overridePythonAttrs (old: rec {
       version = "3.0.3";
       src = old.src.override {
···
 
 buildPythonApplication rec {
   pname = "FlexGet";
-  version = "2.17.14";
+  version = "2.17.20";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "1wh12nspjzsgb0a7qp67s4k8wssbhhf500s8x8mx2smb1mgy4xzz";
+    sha256 = "a09ef9482ed54f7e96eb8b4d08c59687c5c43a3341c9d2675383693e6c3681c3";
   };
 
   postPatch = ''
+    # build for the correct python version
+    substituteInPlace setup.cfg --replace $'[bdist_wheel]\npython-tag = py27' ""
     # remove dependency constraints
     sed 's/==\([0-9]\.\?\)\+//' -i requirements.txt
   '';
···
   doCheck = false;
 
   propagatedBuildInputs = [
+    # See https://github.com/Flexget/Flexget/blob/master/requirements.in
     feedparser sqlalchemy pyyaml
-    chardet beautifulsoup4 html5lib
+    beautifulsoup4 html5lib
     PyRSS2Gen pynzb rpyc jinja2
-    jsonschema requests dateutil
+    requests dateutil jsonschema
     pathpy guessit APScheduler
     terminaltables colorclass
     cherrypy flask flask-restful
     flask-restplus flask-compress
-    flask_login flask-cors safe
-    pyparsing future zxcvbn-python
-    werkzeug tempora cheroot rebulk
-    portend transmissionrpc aniso8601
-    babelfish certifi click futures
-    idna itsdangerous markupsafe
-    plumbum pytz six tzlocal urllib3
-    webencodings werkzeug zxcvbn-python
-    backports_functools_lru_cache
-  ] ++ lib.optional (pythonOlder "3.4") pathlib
-    ++ lib.optional delugeSupport deluge;
+    flask_login flask-cors
+    pyparsing zxcvbn-python future
+    # Optional requirements
+    deluge-client
+  ] ++ lib.optional (pythonOlder "3.4") pathlib;
 
   meta = with lib; {
     homepage    = https://flexget.com/;

pkgs/applications/networking/gns3/server.nix

···
 { stable, branch, version, sha256Hash }:
 
-{ stdenv, python3Packages, fetchFromGitHub, fetchurl }:
+{ stdenv, python36Packages, fetchFromGitHub, fetchurl }:
 
 let
-  pythonPackages = python3Packages;
-  async-timeout = (stdenv.lib.overrideDerivation pythonPackages.async-timeout
+  pythonPackages = python36Packages;
+  async-timeout = pythonPackages.async-timeout.overrideAttrs
     (oldAttrs:
       rec {
         pname = "async-timeout";
···
           inherit pname version;
           sha256 = "1l3kg062m02mph6rf9rdv8r5c5n356clxa6b6mrn0i77vk9g9kq0";
         };
-      }));
-  aiohttp = (stdenv.lib.overrideDerivation pythonPackages.aiohttp
+      });
+  aiohttp = pythonPackages.aiohttp.overrideAttrs
     (oldAttrs:
       rec {
         pname = "aiohttp";
···
           sha256 = "8adda6583ba438a4c70693374e10b60168663ffa6564c5c75d3c7a9055290964";
         };
         propagatedBuildInputs = [ async-timeout ]
-          ++ (with pythonPackages; [ attrs chardet multidict yarl ])
-          ++ stdenv.lib.optional (pythonPackages.pythonOlder "3.7") pythonPackages.idna-ssl;
-      }));
-  aiohttp-cors = (stdenv.lib.overrideDerivation pythonPackages.aiohttp-cors
+          ++ (with pythonPackages; [ attrs chardet multidict yarl idna-ssl ]);
+      });
+  aiohttp-cors = pythonPackages.aiohttp-cors.overrideAttrs
     (oldAttrs:
       rec {
         pname = "aiohttp-cors";
···
           ++ stdenv.lib.optional
                (pythonPackages.pythonOlder "3.5")
                pythonPackages.typing;
-      }));
+      });
 in pythonPackages.buildPythonPackage rec {
   name = "${pname}-${version}";
   pname = "gns3-server";
···
     ++ (with pythonPackages; [
       yarl aiohttp multidict
       jinja2 psutil zipstream raven jsonschema typing
-      prompt_toolkit
+      (pythonPackages.callPackage ../../../development/python-modules/prompt_toolkit/1.nix {})
     ]);
 
   # Requires network access

pkgs/applications/networking/instant-messengers/pidgin-plugins/msn-pecan/default.nix

···
     platforms = stdenv.lib.platforms.linux;
   };
 
-  makeFlags = "PURPLE_LIBDIR=lib PURPLE_DATADIR=share/data DESTDIR=$$out";
-  preInstall = "mkdir -p \$out/share";
-  postInstall = "ln -s \$out/lib/purple-2 \$out/share/pidgin-msn-pecan";
+  makeFlags = [
+    "PURPLE_LIBDIR=${placeholder "out"}/lib"
+    "PURPLE_DATADIR=${placeholder "out"}/share/data"
+  ];
 
   buildInputs = [pidgin];
 }

pkgs/applications/networking/instant-messengers/pidgin-plugins/pidgin-mra/default.nix

···
   nativeBuildInputs = [ pkgconfig ];
   buildInputs = [ pidgin ];
 
-  preConfigure = ''
+  postPatch = ''
     sed -i 's|-I/usr/include/libpurple|$(shell pkg-config --cflags purple)|' Makefile
-    export DESTDIR=$out
-    export LIBDIR=/lib
-    export DATADIR=/share
   '';
+
+  makeFlags = [
+    "DESTDIR=/"
+    "LIBDIR=${placeholder "out"}/lib"
+    "DATADIR=${placeholder "out"}/share"
+  ];
 
   meta = {
     homepage = https://github.com/dreadatour/pidgin-mra;

pkgs/applications/networking/instant-messengers/pidgin-plugins/pidgin-opensteamworks/default.nix

···
-{ stdenv, fetchFromGitHub, pidgin, unzip, glib, json-glib, nss, nspr, libgnome-keyring } :
+{ stdenv, fetchFromGitHub, pidgin, glib, json-glib, nss, nspr, libgnome-keyring } :
 
 stdenv.mkDerivation rec {
   name = "pidgin-opensteamworks-${version}";
···
 
   preConfigure = "cd steam-mobile";
   installFlags = [
-    "DESTDIR=$(out)"
-    "PLUGIN_DIR_PURPLE=/lib/purple-2"
-    "DATA_ROOT_DIR_PURPLE=/share"
+    "PLUGIN_DIR_PURPLE=${placeholder "out"}/lib/purple-2"
+    "DATA_ROOT_DIR_PURPLE=${placeholder "out"}/share"
   ];
 
-  buildInputs = [ pidgin unzip glib json-glib nss nspr libgnome-keyring ];
+  buildInputs = [ pidgin glib json-glib nss nspr libgnome-keyring ];
 
   meta = with stdenv.lib; {
     homepage = https://github.com/EionRobb/pidgin-opensteamworks;

pkgs/applications/networking/instant-messengers/pidgin-plugins/pidgin-skypeweb/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "pidgin-skypeweb-${version}";
-  version = "1.2.2";
+  version = "1.5";
 
   src = fetchFromGitHub {
     owner = "EionRobb";
     repo = "skype4pidgin";
-    rev = "${version}";
-    sha256 = "1lxpz316jmns6i143v4j6sd6k0a4a54alw08rvwjckf2rig57lj2";
+    rev = version;
+    sha256 = "1bd9gd36yhrbrww0dvai9rnzxxj1c9sb4003c72wg27w12y47xfv";
   };
 
   setSourceRoot = ''
···
   nativeBuildInputs = [ pkgconfig ];
   buildInputs = [ pidgin json-glib ];
 
-  makeFlags = [
-    "PLUGIN_DIR_PURPLE=/lib/pidgin/"
-    "DATA_ROOT_DIR_PURPLE=/share"
-    "DESTDIR=$(out)"
-  ];
-
-  postInstall = "ln -s \$out/lib/pidgin \$out/share/pidgin-skypeweb";
+  PKG_CONFIG_PURPLE_PLUGINDIR = "${placeholder "out"}/lib/purple-2";
+  PKG_CONFIG_PURPLE_DATADIR = "${placeholder "out"}/share";
 
   meta = with stdenv.lib; {
     homepage = https://github.com/EionRobb/skype4pidgin;

pkgs/applications/networking/instant-messengers/pidgin-plugins/purple-discord/default.nix

···
   nativeBuildInputs = [ pkgconfig ];
   buildInputs = [ pidgin json-glib ];
 
-  makeFlags = [
-    "DESTDIR=$(out)"
-  ];
-
-  PKG_CONFIG_PURPLE_PLUGINDIR = "/lib/purple-2";
-  PKG_CONFIG_PURPLE_DATADIR = "/share";
+  PKG_CONFIG_PURPLE_PLUGINDIR = "${placeholder "out"}/lib/purple-2";
+  PKG_CONFIG_PURPLE_DATADIR = "${placeholder "out"}/share";
 
   meta = with stdenv.lib; {
     homepage = https://github.com/EionRobb/purple-discord;

pkgs/applications/networking/instant-messengers/pidgin-plugins/purple-matrix/default.nix

···
   hardeningDisable = [ "fortify" ]; # upstream compiles with -O0
 
   makeFlags = [
-    "DESTDIR=$(out)"
-    "PLUGIN_DIR_PURPLE=/lib/pidgin/"
-    "DATA_ROOT_DIR_PURPLE=/share"
+    "PLUGIN_DIR_PURPLE=${placeholder "out"}/lib/purple-2"
+    "DATA_ROOT_DIR_PURPLE=${placeholder "out"}/share"
   ];
 
   meta = with stdenv.lib; {

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

···
 let configFile = writeText "riot-config.json" conf; in
 stdenv.mkDerivation rec {
   name= "riot-web-${version}";
-  version = "0.17.6";
+  version = "0.17.8";
 
   src = fetchurl {
     url = "https://github.com/vector-im/riot-web/releases/download/v${version}/riot-v${version}.tar.gz";
-    sha256 = "1y38fq0r9cxmazh9rjc5qy7fzwy81ad35k538d6rsfwz1y88ipdm";
+    sha256 = "0610h307q0zlyd0l7afrb8jv1r9gy9gc07zkjn33jpycwmpbwxbz";
   };
 
   installPhase = ''

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

···
   mkTelegram = args: qt5.callPackage (import ./generic.nix args) { };
   stableVersion = {
     stable = true;
-    version = "1.5.2";
-    sha256Hash = "0kg1xw1b4zj5a2yf6x5r7wrpl7w0fs52s58w606n9gyx7kdcgkj8";
+    version = "1.5.4";
+    sha256Hash = "0a52m5qkvk01yl3za3k7pccjrqkr8gbxqnj5lnhh1im1pdxqwh4m";
     # svn log svn://svn.archlinux.org/community/telegram-desktop/trunk
     archPatchesRevision = "415526";
     archPatchesHash = "1lfzws90ab0vajhm5r64gyyqqc1g6a2ay0a1vkp0ah1iw5jh11ik";

pkgs/applications/networking/instant-messengers/telegram/tdesktop/generic.nix

···
   };
 
   # TODO: libtgvoip.patch no-gtk2.patch
-  patches = [ "${archPatches}/tdesktop.patch" ]
+  patches = [
+      "${archPatches}/tdesktop.patch"
+    ]
     # TODO: Only required to work around a compiler bug.
     # This should be fixed in GCC 7.3.1 (or later?)
     ++ [ ./fix-internal-compiler-error.patch ];

pkgs/applications/networking/syncplay/default.nix

···
 
 python3Packages.buildPythonApplication rec {
   name = "syncplay-${version}";
-  version = "1.6.0";
+  version = "1.6.1";
 
   format = "other";
 
   src = fetchurl {
-    url = https://github.com/Syncplay/syncplay/archive/v1.6.0.tar.gz;
-    sha256 = "19x7b694p8b3qp578qk8q4g0pybhfjd4zk8rgrggz40s1yyfnwy5";
+    url = https://github.com/Syncplay/syncplay/archive/v1.6.1.tar.gz;
+    sha256 = "15rhbc3r7l012d330hb64p8bhcpy4ydy89iv34c34a1r554b8k97";
   };
 
   propagatedBuildInputs = with python3Packages; [ pyside twisted ];

pkgs/applications/networking/syncthing/default.nix

···
 let
   common = { stname, target, postInstall ? "" }:
     buildGoPackage rec {
-      version = "0.14.52";
+      version = "0.14.54";
       name = "${stname}-${version}";
 
       src = fetchFromGitHub {
         owner  = "syncthing";
         repo   = "syncthing";
         rev    = "v${version}";
-        sha256 = "1qzzbqfyjqlgzysyf6dr0xsm3gn35irmllxjjd94v169swvkk5kd";
+        sha256 = "0l73ka71l6gxv46wmlyzj8zhfpfj3vf6nv6x3x0z25ymr3wa2fza";
       };
 
       goPackagePath = "github.com/syncthing/syncthing";

pkgs/applications/office/gnumeric/default.nix

···
 
 let
   inherit (pythonPackages) python pygobject3;
-  isopub = fetchurl { url = http://www.oasis-open.org/docbook/xml/4.5/ent/isopub.ent; sha256 = "073l492jz70chcadr2p7ssx7gz5hd731s2cazhxx4r845kilyr77"; };
-  isonum = fetchurl { url = http://www.oasis-open.org/docbook/xml/4.5/ent/isonum.ent; sha256 = "04b62dw2g3cj9i4vn9xyrsrlz8fpmmijq98dm0nrkky31bwbbrs3"; };
-  isogrk1 = fetchurl { url = http://www.oasis-open.org/docbook/xml/4.5/ent/isogrk1.ent; sha256 = "04b23anhs5wr62n4rgsjirzvw7rpjcsf8smz4ffzaqh3b0vw90vm"; };
 in stdenv.mkDerivation rec {
-  name = "gnumeric-1.12.43";
+  pname = "gnumeric";
+  version = "1.12.44";
 
   src = fetchurl {
-    url = "mirror://gnome/sources/gnumeric/1.12/${name}.tar.xz";
-    sha256 = "87c9abd6260cf29401fa1e0fcce374e8c7bcd1986608e4049f6037c9d32b5fd5";
+    url = "mirror://gnome/sources/${pname}/${stdenv.lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
+    sha256 = "0147962c6ybdsj57rz95nla0rls7g545wc2n7pz59zmzyd5pksk0";
   };
 
   configureFlags = [ "--disable-component" ];
 
-  prePatch = ''
-    substituteInPlace doc/C/gnumeric.xml \
-      --replace http://www.oasis-open.org/docbook/xml/4.5/ent/isopub.ent ${isopub} \
-      --replace http://www.oasis-open.org/docbook/xml/4.5/ent/isonum.ent ${isonum} \
-      --replace http://www.oasis-open.org/docbook/xml/4.5/ent/isogrk1.ent ${isogrk1}
-  '';
-
-  nativeBuildInputs = [ pkgconfig ];
+  nativeBuildInputs = [ pkgconfig intltool bison itstool makeWrapper ];
 
   # ToDo: optional libgda, introspection?
   buildInputs = [
-    intltool bison
-    goffice gtk3 makeWrapper gnome3.defaultIconTheme
-    python pygobject3 itstool
+    goffice gtk3 gnome3.defaultIconTheme
+    python pygobject3
   ] ++ (with perlPackages; [ perl XMLParser ]);
 
   enableParallelBuilding = true;
···
         ${stdenv.lib.optionalString (!stdenv.isDarwin) "--prefix GIO_EXTRA_MODULES : '${stdenv.lib.getLib gnome3.dconf}/lib/gio/modules'"}
     done
   '';
+
+  passthru = {
+    updateScript = gnome3.updateScript {
+      packageName = pname;
+    };
+  };
 
   meta = with stdenv.lib; {
     description = "The GNOME Office Spreadsheet";

pkgs/applications/office/zim/default.nix

···
 
 python2Packages.buildPythonApplication rec {
   name = "zim-${version}";
-  version = "0.68";
+  version = "0.69";
 
   src = fetchurl {
     url = "http://zim-wiki.org/downloads/${name}.tar.gz";
-    sha256 = "05fzb24a2s3pm89zb6gwa48wb925an5i652klx8yk9pn23h1h5fr";
+    sha256 = "1j04l1914iw87b0jd3r1czrh0q491fdgbqbi0biacxiri5q0i6a1";
   };
 
   propagatedBuildInputs = with python2Packages; [ pyGtkGlade pyxdg pygobject2 ];
···
     homepage = http://zim-wiki.org;
     license = licenses.gpl2Plus;
     maintainers = with maintainers; [ pSub ];
+    broken = stdenv.isDarwin; # https://github.com/NixOS/nixpkgs/pull/52658#issuecomment-449565790
   };
 }

pkgs/applications/science/biology/picard-tools/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "picard-tools-${version}";
-  version = "2.18.17";
+  version = "2.18.20";
 
   src = fetchurl {
     url = "https://github.com/broadinstitute/picard/releases/download/${version}/picard.jar";
-    sha256 = "0ks7ymrjfya5h77hp0bqyipzdri0kf97c8wks32nvwkj821687zm";
+    sha256 = "0dx6fxn6d7mawkah242fdi9wm8pdzmm4m004fb9ak2fsvrs2m5pk";
   };
 
   nativeBuildInputs = [ makeWrapper ];

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

···
+{ stdenv, fetchFromGitHub, pkgconfig, cmake, autoreconfHook,
+glib, libzip, boost, fftw, qtbase,
+libusb, makeWrapper, libsigrok4dsl, libsigrokdecode4dsl
+}:
+
+stdenv.mkDerivation rec {
+  name = "dsview-${version}";
+
+  version = "0.99";
+
+  src = fetchFromGitHub {
+      owner = "DreamSourceLab";
+      repo = "DSView";
+      rev = version;
+      sha256 = "189i3baqgn8k3aypalayss0g489xi0an9hmvyggvxmgg1cvcwka2";
+  };
+
+  postUnpack = ''
+    export sourceRoot=$sourceRoot/DSView
+  '';
+
+  patches = [
+    # Fix absolute install paths
+    ./install.patch
+  ];
+
+  nativeBuildInputs = [ cmake pkgconfig makeWrapper ];
+
+  buildInputs = [
+   boost fftw qtbase libusb libzip libsigrokdecode4dsl libsigrok4dsl
+  ];
+
+  enableParallelBuilding = true;
+
+  postFixup = ''
+    wrapProgram $out/bin/DSView --suffix QT_PLUGIN_PATH : \
+      ${qtbase.bin}/${qtbase.qtPluginPrefix}
+  '';
+
+  meta = with stdenv.lib; {
+    description = "A GUI program for supporting various instruments from DreamSourceLab, including logic analyzer, oscilloscope, etc";
+    homepage = http://www.dreamsourcelab.com/;
+    license = licenses.gpl3Plus;
+    platforms = platforms.linux;
+    maintainers = [ maintainers.bachp ];
+  };
+}

pkgs/applications/science/electronics/dsview/install.patch

···
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index c1c33e1..208a184 100644
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -403,8 +403,8 @@ install(DIRECTORY res DESTINATION share/${PROJECT_NAME})
+ install(FILES icons/logo.png DESTINATION share/${PROJECT_NAME} RENAME logo.png)
+ install(FILES ../NEWS DESTINATION share/${PROJECT_NAME} RENAME NEWS)
+ install(FILES ../ug.pdf DESTINATION share/${PROJECT_NAME} RENAME ug.pdf)
+-install(FILES DreamSourceLab.rules DESTINATION /etc/udev/rules.d/)
+-install(FILES DSView.desktop DESTINATION /usr/share/applications/)
++install(FILES DreamSourceLab.rules DESTINATION etc/udev/rules.d/)
++install(FILES DSView.desktop DESTINATION share/applications/)
+ 
+ #===============================================================================
+ #= Packaging (handled by CPack)

pkgs/applications/science/electronics/dsview/libsigrok4dsl.nix

···
+{ stdenv, pkgconfig, autoreconfHook,
+glib, libzip, libserialport, check, libusb, libftdi,
+systemd, alsaLib, dsview
+}:
+
+stdenv.mkDerivation rec {
+  inherit (dsview) version src;
+
+  name = "libsigrok4dsl-${version}";
+
+  postUnpack = ''
+    export sourceRoot=$sourceRoot/libsigrok4DSL
+  '';
+
+  nativeBuildInputs = [ pkgconfig autoreconfHook ];
+
+  buildInputs = [
+    glib libzip libserialport libusb libftdi systemd check alsaLib
+  ];
+
+  meta = with stdenv.lib; {
+    description = "A fork of the sigrok library for usage with DSView";
+    homepage = http://www.dreamsourcelab.com/;
+    license = licenses.gpl3Plus;
+    platforms = platforms.linux;
+    maintainers = [ maintainers.bachp ];
+  };
+}

pkgs/applications/science/electronics/dsview/libsigrokdecode4dsl.nix

···
+{ stdenv, pkgconfig, autoreconfHook,
+glib, check, python3, dsview
+}:
+
+stdenv.mkDerivation rec {
+  inherit (dsview) version src;
+
+  name = "libsigrokdecode4dsl-${version}";
+
+  postUnpack = ''
+    export sourceRoot=$sourceRoot/libsigrokdecode4DSL
+  '';
+
+  nativeBuildInputs = [ pkgconfig autoreconfHook ];
+
+  buildInputs = [
+    python3 glib check
+  ];
+
+  meta = with stdenv.lib; {
+    description = "A fork of the sigrokdecode library for usage with DSView";
+    homepage = http://www.dreamsourcelab.com/;
+    license = licenses.gpl3Plus;
+    platforms = platforms.linux;
+    maintainers = [ maintainers.bachp ];
+  };
+}

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

···
 
 stdenv.mkDerivation rec {
   name    = "verilator-${version}";
-  version = "4.006";
+  version = "4.008";
 
   src = fetchurl {
     url    = "https://www.veripool.org/ftp/${name}.tgz";
-    sha256 = "0vnybpknf4llw3fw800ffiqj89ilbq06j8b2x4syj2gsrlnjvp1i";
+    sha256 = "1b0cj7bb2a3hrfaziix7p9idcpbygapdl0nrfr3pbdxxsgnzdknm";
   };
 
   enableParallelBuilding = true;

pkgs/applications/science/logic/aspino/default.nix

···
     platforms = platforms.unix;
     license = licenses.asl20;
     homepage = http://alviano.net/software/maxino/;
+    # See pkgs/applications/science/logic/glucose/default.nix
+    badPlatforms = [ "aarch64-linux" ];
   };
 }

pkgs/applications/science/logic/avy/default.nix

···
     license     = stdenv.lib.licenses.mit;
     maintainers = with stdenv.lib.maintainers; [ thoughtpolice ];
     platforms   = stdenv.lib.platforms.linux;
+    # See pkgs/applications/science/logic/glucose/default.nix
+    # (The error is different due to glucose-fenv.patch, but the same)
+    badPlatforms = [ "aarch64-linux" ];
   };
 }

pkgs/applications/science/logic/glucose/default.nix

···
     license = licenses.mit;
     platforms = platforms.unix;
     maintainers = with maintainers; [ gebner ];
+    # Build uses _FPU_EXTENDED macro
+    badPlatforms = [ "aarch64-linux" ];
   };
 }

pkgs/applications/science/math/R/default.nix

···
 }:
 
 stdenv.mkDerivation rec {
-  name = "R-3.5.1";
+  name = "R-3.5.2";
 
   src = fetchurl {
     url = "https://cran.r-project.org/src/base/R-3/${name}.tar.gz";
-    sha256 = "0463bff5eea0f3d93fa071f79c18d0993878fd4f2e18ae6cf22c1639d11457ed";
+    sha256 = "0qjvdic1qd5vndc4f0wjndpm0x18lbvbcc8nkix8saqgy8y8qgg5";
   };
 
   dontUseImakeConfigure = true;

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

···
-{ stdenv, lib, fetchFromGitHub, makeWrapper, git, gnupg }:
+{ stdenv, lib, fetchFromGitHub, makeWrapper, git, gnupg, gawk }:
 
 let
   version = "0.2.4";
···
     install -D git-secret $out/bin/git-secret
 
     wrapProgram $out/bin/git-secret \
-      --prefix PATH : "${lib.makeBinPath [ git gnupg ]}"
+      --prefix PATH : "${lib.makeBinPath [ git gnupg gawk ]}"
 
     mkdir $out/share
     cp -r man $out/share

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

···
 
 stdenv.mkDerivation rec {
   name = "git-repo-${version}";
-  version = "1.13.0";
+  version = "1.13.1";
 
   src = fetchFromGitHub {
     owner = "android";
     repo = "tools_repo";
     rev = "v${version}";
-    sha256 = "0078nyz2j3ci9rs0h104xh046n0mcls3xcw5mysi2r7453xj8fkn";
+    sha256 = "09p0xv8x7mkmibri7rcl1k4dwh2gj3c7dipkrwrsir6hrwsispd1";
   };
 
   nativeBuildInputs = [ makeWrapper ];

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

···
 
 buildGoPackage rec {
   name = "gitea-${version}";
-  version = "1.6.0";
+  version = "1.6.2";
 
   src = fetchFromGitHub {
     owner = "go-gitea";
     repo = "gitea";
     rev = "v${version}";
-    sha256 = "01nqf8pnpa0n72brqh499z15rys6f0ck7l2cnpbiqgg3kir8b21p";
+    sha256 = "1ijxpihdg8k6gs1xpim0iviqakvjadjzp0a5ki2czykilnyg8y85";
     # Required to generate the same checksum on MacOS due to unicode encoding differences
     # More information: https://github.com/NixOS/nixpkgs/pull/48128
     extraPostFetch = ''
···
 
   nativeBuildInputs = [ makeWrapper ];
 
-  buildFlags = optionalString sqliteSupport "-tags sqlite";
+  buildFlags = optional sqliteSupport "-tags sqlite";
+  buildFlagsArray = ''
+    -ldflags=
+      -X=main.Version=${version}
+      ${optionalString sqliteSupport "-X=main.Tags=sqlite"}
+  '';
 
   outputs = [ "bin" "out" "data" ];
 

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

···
       cp -v hgweb.cgi contrib/hgweb.wsgi $out/share/cgi-bin
       chmod u+x $out/share/cgi-bin/hgweb.cgi
 
-      # install bash completion
-      install -D -v contrib/bash_completion $out/share/bash-completion/completions/mercurial
+      # install bash/zsh completions
+      install -v -m644 -D contrib/bash_completion $out/share/bash-completion/completions/_hg
+      install -v -m644 -D contrib/zsh_completion $out/share/zsh/site-functions/_hg
     '';
 
   meta = {

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

···
 
 stdenv.mkDerivation rec {
   name = "src-${version}";
-  version = "1.18";
+  version = "1.22";
 
   src = fetchurl {
     url = "http://www.catb.org/~esr/src/${name}.tar.gz";
-    sha256 = "0n0skhvya8w2az45h2gsafxy8m2mvqas64nrgxifcmrzfv0rf26c";
+    sha256 = "0xvfg3aikr2jh09vjvxsha7day5br88chvirncr59ad40da1fils";
   };
 
   buildInputs = [ python rcs git makeWrapper ];

pkgs/applications/video/vdr/default.nix

···
+{ stdenv, fetchurl, fontconfig, libjpeg, libcap, freetype, fribidi, pkgconfig
+, gettext, ncurses, systemd, perl
+, enableSystemd ? true
+, enableBidi ? true
+}:
+let
+
+  version = "2.4.0";
+
+  name = "vdr-${version}";
+
+  mkPlugin = name: stdenv.mkDerivation {
+    name = "vdr-${name}-${version}";
+    inherit (vdr) src;
+    buildInputs = [ vdr ];
+    preConfigure = "cd PLUGINS/src/${name}";
+    installFlags = [ "DESTDIR=$(out)" ];
+  };
+
+  vdr = stdenv.mkDerivation {
+
+    inherit name;
+
+    src = fetchurl {
+      url = "ftp://ftp.tvdr.de/vdr/${name}.tar.bz2";
+      sha256 = "1klcgy9kr7n6z8d2c77j63bl8hvhx5qnqppg73f77004hzz4kbwk";
+    };
+
+    enableParallelBuilding = true;
+
+    postPatch = "substituteInPlace Makefile --replace libsystemd-daemon libsystemd";
+
+    buildInputs = [ fontconfig libjpeg libcap freetype ]
+    ++ stdenv.lib.optional enableSystemd systemd
+    ++ stdenv.lib.optional enableBidi fribidi;
+
+    buildFlags = [ "vdr" "i18n" ]
+    ++ stdenv.lib.optional enableSystemd "SDNOTIFY=1"
+    ++ stdenv.lib.optional enableBidi "BIDI=1";
+
+    nativeBuildInputs = [ perl ];
+
+    # plugins uses the same build environment as vdr
+    propagatedNativeBuildInputs = [ pkgconfig gettext ];
+
+    installFlags = [
+      "DESTDIR=$(out)"
+      "PREFIX=" # needs to be empty, otherwise plugins try to install at same prefix
+    ];
+
+    installTargets = [ "install-pc" "install-bin" "install-doc" "install-i18n"
+      "install-includes" ];
+
+    postInstall = ''
+      mkdir -p $out/lib/vdr # only needed if vdr is started without any plugin
+      mkdir -p $out/share/vdr/conf
+      cp *.conf $out/share/vdr/conf
+      '';
+
+    outputs = [ "out" "dev" "man" ];
+
+    meta = with stdenv.lib; {
+      homepage = http://www.tvdr.de/;
+      description = "Video Disc Recorder";
+      maintainers = [ maintainers.ck3d ];
+      platforms = [ "i686-linux" "x86_64-linux" ];
+      license = licenses.gpl2;
+    };
+
+  };
+in vdr // {
+  plugins = {
+    skincurses = (mkPlugin "skincurses").overrideAttrs(
+    oldAttr: { buildInputs = oldAttr.buildInputs ++ [ ncurses ]; });
+  } // (stdenv.lib.genAttrs [
+    "epgtableid0" "hello" "osddemo" "pictures" "servicedemo" "status" "svdrpdemo"
+  ] mkPlugin);
+}

pkgs/applications/video/vdr/plugins.nix

···
+{ stdenv, fetchurl, fetchgit, vdr, ffmpeg_2, alsaLib, fetchFromGitHub
+, libvdpau, libxcb, xcbutilwm, graphicsmagick, libav, pcre, xorgserver, ffmpeg
+, libiconv, boost, libgcrypt, perl, utillinux, groff, libva, xorg }:
+{
+  femon = stdenv.mkDerivation rec {
+
+    name = "vdr-femon-2.4.0";
+
+    buildInputs = [ vdr ];
+
+    src = fetchurl {
+      url = "http://www.saunalahti.fi/~rahrenbe/vdr/femon/files/${name}.tgz";
+      sha256 = "1hra1xslj8s68zbyr8zdqp8yap0aj1p6rxyc6cwy1j122kwcnapp";
+    };
+
+    postPatch = "substituteInPlace Makefile --replace /bin/true true";
+
+    makeFlags = [ "DESTDIR=$(out)" ];
+
+    meta = with stdenv.lib; {
+      homepage = http://www.saunalahti.fi/~rahrenbe/vdr/femon/;
+      description = "DVB Frontend Status Monitor plugin for VDR";
+      maintainers = [ maintainers.ck3d ];
+      license = licenses.gpl2;
+      platforms = [ "i686-linux" "x86_64-linux" ];
+    };
+
+  };
+
+  vaapidevice = stdenv.mkDerivation {
+
+    name = "vdr-vaapidevice-0.7.0";
+
+    buildInputs = [
+      vdr libxcb xcbutilwm ffmpeg
+      alsaLib
+      libvdpau # vdpau
+      libva # va-api
+    ] ++ (with xorg; [ libxcb libX11 ]);
+
+    makeFlags = [ "DESTDIR=$(out)" ];
+
+    postPatch = ''
+      substituteInPlace softhddev.c --replace /usr/bin/X ${xorgserver}/bin/X
+    '';
+
+    src = fetchFromGitHub {
+      owner = "pesintta";
+      repo = "vdr-plugin-vaapidevice";
+      sha256 = "072y61fpkh3i2dragg0nsd4g3malgwxkwpdrb1ykdljyzf52s5hs";
+      rev = "c99afc23a53e6d91f9afaa99af59b30e68e626a8";
+    };
+
+    meta = with stdenv.lib; {
+      homepage = https://github.com/pesintta/vdr-plugin-vaapidevice;
+      description = "VDR SoftHDDevice Plug-in (with VA-API VPP additions)";
+      maintainers = [ maintainers.ck3d ];
+      license = licenses.gpl2;
+      platforms = [ "i686-linux" "x86_64-linux" ];
+    };
+
+  };
+
+
+  markad = stdenv.mkDerivation rec {
+    name = "vdr-markad-2017-03-13";
+
+    src = fetchgit {
+      url = "git://projects.vdr-developer.org/vdr-plugin-markad.git";
+      sha256 = "0jvy70r8bcmbs7zdqilfz019z5xkz5c6rs57h1dsgv8v6x86c2i4";
+      rev = "ea2e182ec798375f3830f8b794e7408576f139ad";
+    };
+
+    buildInputs = [ vdr libav ];
+
+    postPatch = ''
+      substituteInPlace command/Makefile --replace '$(DESTDIR)/usr' '$(DESTDIR)'
+
+      substituteInPlace plugin/markad.cpp \
+        --replace "/usr/bin" "$out/bin" \
+        --replace "/var/lib/markad" "$out/var/lib/markad"
+
+      substituteInPlace command/markad-standalone.cpp \
+        --replace "/var/lib/markad" "$out/var/lib/markad"
+    '';
+
+    preBuild = ''
+      mkdir -p $out/lib/vdr
+    '';
+
+    buildFlags = [
+      "DESTDIR=$(out)"
+      "LIBDIR=$(out)/lib/vdr"
+      "VDRDIR=${vdr.dev}/include/vdr"
+      "LOCALEDIR=$(DESTDIR)/share/locale"
+    ];
+
+    installFlags = buildFlags;
+
+    meta = with stdenv.lib; {
+      homepage = https://projects.vdr-developer.org/projects/plg-markad;
+      description = "Ein Programm zum automatischen Setzen von Schnittmarken bei Werbeeinblendungen während einer Sendung.";
+      maintainers = [ maintainers.ck3d ];
+      license = licenses.gpl2;
+      platforms = [ "i686-linux" "x86_64-linux" ];
+    };
+
+  };
+
+  epgsearch = stdenv.mkDerivation rec {
+    pname = "vdr-epgsearch";
+    version = "2.4.0";
+
+    src = fetchurl {
+      url = "https://projects.vdr-developer.org/git/vdr-plugin-epgsearch.git/snapshot/vdr-plugin-epgsearch-${version}.tar.bz2";
+      sha256 = "0xfgn17vicyjwdf0rbkrik4q16mnfi305d4wmi8f0qk825pa0z3y";
+    };
+
+    postPatch = ''
+      for f in *.sh; do
+        patchShebangs "$f"
+      done
+    '';
+
+    nativeBuildInputs = [
+      perl # for pod2man and pos2html
+      utillinux
+      groff
+    ];
+
+    buildInputs = [
+      vdr
+      pcre
+    ];
+
+    buildFlags = [
+      "SENDMAIL="
+      "REGEXLIB=pcre"
+    ];
+
+    installFlags = [
+      "DESTDIR=$(out)"
+    ];
+
+    outputs = [ "out" "man" ];
+
+    meta = with stdenv.lib; {
+      homepage = http://winni.vdr-developer.org/epgsearch;
+      description = "Searchtimer and replacement of the VDR program menu";
+      maintainers = [ maintainers.ck3d ];
+      license = licenses.gpl2;
+      platforms = [ "i686-linux" "x86_64-linux" ];
+    };
+
+  };
+
+  vnsiserver = let
+    name = "vnsiserver";
+    version = "1.8.0";
+  in stdenv.mkDerivation {
+    name = "vdr-${name}-${version}";
+
+    buildInputs = [ vdr ];
+
+    installFlags = [ "DESTDIR=$(out)" ];
+
+    src = fetchFromGitHub {
+      repo = "vdr-plugin-${name}";
+      owner = "FernetMenta";
+      rev = "v${version}";
+      sha256 = "0n7idpxqx7ayd63scl6xwdx828ik4kb2mwz0c30cfjnmnxxd45lw";
+    };
+
+    meta = with stdenv.lib; {
+      homepage = https://github.com/FernetMenta/vdr-plugin-vnsiserver;
+      description = "VDR plugin to handle KODI clients.";
+      maintainers = [ maintainers.ck3d ];
+      license = licenses.gpl2;
+      platforms = [ "i686-linux" "x86_64-linux" ];
+    };
+
+  };
+
+  text2skin = stdenv.mkDerivation rec {
+    name = "vdr-text2skin-1.3.4-20170702";
+
+    src = fetchgit {
+      url = "git://projects.vdr-developer.org/vdr-plugin-text2skin.git";
+      sha256 = "19hkwmaw6nwak38bv6cm2vcjjkf4w5yjyxb98qq6zfjjh5wq54aa";
+      rev = "8f7954da2488ced734c30e7c2704b92a44e6e1ad";
+    };
+
+    buildInputs = [ vdr graphicsmagick ];
+
+    buildFlags = [
+      "DESTDIR=$(out)"
+      "IMAGELIB=graphicsmagic"
+      "VDRDIR=${vdr.dev}/include/vdr"
+      "LOCALEDIR=$(DESTDIR)/share/locale"
+      "LIBDIR=$(DESTDIR)/lib/vdr"
+    ];
+
+    preBuild = ''
+      mkdir -p $out/lib/vdr
+    '';
+
+    installPhase = ":";
+
+    meta = with stdenv.lib; {
+      homepage = https://projects.vdr-developer.org/projects/plg-text2skin;
+      description = "VDR Text2Skin Plugin";
+      maintainers = [ maintainers.ck3d ];
+      license = licenses.gpl2;
+      platforms = [ "i686-linux" "x86_64-linux" ];
+    };
+  };
+
+  fritzbox = let
+    libconvpp = stdenv.mkDerivation {
+      name = "jowi24-libconv++-20130216";
+      propagatedBuildInputs = [ libiconv ];
+      CXXFLAGS = "-std=gnu++11 -Os";
+      src = fetchFromGitHub {
+        owner = "jowi24";
+        repo = "libconvpp";
+        rev = "90769b2216bc66c5ea5e41a929236c20d367c63b";
+        sha256 = "0bf0dwxrzd42l84p8nxcsjdk1gvzlhad93nsbn97z6kr61n4cr33";
+      };
+      installPhase = ''
+        mkdir -p $out/lib $out/include/libconv++
+        cp source.a $out/lib/libconv++.a
+        cp *.h $out/include/libconv++
+      '';
+    };
+
+    liblogpp = stdenv.mkDerivation {
+      name = "jowi24-liblogpp-20130216";
+      CXXFLAGS = "-std=gnu++11 -Os";
+      src = fetchFromGitHub {
+        owner = "jowi24";
+        repo = "liblogpp";
+        rev = "eee4046d2ae440974bcc8ceec00b069f0a2c62b9";
+        sha256 = "01aqvwmwh5kk3mncqpim8llwha9gj5qq0c4cvqfn4h8wqi3d9l3p";
+      };
+      installPhase = ''
+        mkdir -p $out/lib $out/include/liblog++
+        cp source.a $out/lib/liblog++.a
+        cp *.h $out/include/liblog++
+      '';
+    };
+
+    libnetpp = stdenv.mkDerivation {
+      name = "jowi24-libnet++-20180628";
+      CXXFLAGS = "-std=gnu++11 -Os";
+      src = fetchFromGitHub {
+        owner = "jowi24";
+        repo = "libnetpp";
+        rev = "212847f0efaeffee8422059b8e202d844174aaf3";
+        sha256 = "0vjl6ld6aj25rzxm26yjv3h2gy7gp7qnbinpw6sf1shg2xim9x0b";
+      };
+      installPhase = ''
+        mkdir -p $out/lib $out/include/libnet++
+        cp source.a $out/lib/libnet++.a
+        cp *.h $out/include/libnet++
+      '';
+      buildInputs = [ boost liblogpp libconvpp ];
+    };
+
+    libfritzpp = stdenv.mkDerivation {
+      name = "jowi24-libfritzpp-20131201";
+      CXXFLAGS = "-std=gnu++11 -Os";
+      src = fetchFromGitHub {
+        owner = "jowi24";
+        repo = "libfritzpp";
+        rev = "ca19013c9451cbac7a90155b486ea9959ced0f67";
+        sha256 = "0jk93zm3qzl9z96gfs6xl1c8ip8lckgbzibf7jay7dbgkg9kyjfg";
+      };
+      installPhase = ''
+        mkdir -p $out/lib $out/include/libfritz++
+        cp source.a $out/lib/libfritz++.a
+        cp *.h $out/include/libfritz++
+      '';
+      propagatedBuildInputs = [ libgcrypt ];
+      buildInputs = [ boost liblogpp libconvpp libnetpp ];
+    };
+
+  in stdenv.mkDerivation rec {
+    pname = "vdr-fritzbox";
+
+    version = "1.5.3";
+
+    src = fetchFromGitHub {
+      owner = "jowi24";
+      repo = "vdr-fritz";
+      rev = version;
+      sha256 = "0wab1kyma9jzhm6j33cv9hd2a5d1334ghgdi2051nmr1bdcfcsw8";
+    };
+
+    postUnpack = ''
+      cp ${libfritzpp}/lib/* $sourceRoot/libfritz++
+      cp ${liblogpp}/lib/* $sourceRoot/liblog++
+      cp ${libnetpp}/lib/* $sourceRoot/libnet++
+      cp ${libconvpp}/lib/* $sourceRoot/libconv++
+    '';
+
+    buildInputs = [ vdr boost libconvpp libfritzpp libnetpp liblogpp ];
+
+    installFlags = [ "DESTDIR=$(out)" ];
+
+    meta = with stdenv.lib; {
+      homepage = https://github.com/jowi24/vdr-fritz;
+      description = "A plugin for VDR to access AVMs Fritz Box routers";
+      maintainers = [ maintainers.ck3d ];
+      license = licenses.gpl2;
+      platforms = [ "i686-linux" "x86_64-linux" ];
+    };
+  };
+}

pkgs/applications/video/vdr/wrapper.nix

···
+{ symlinkJoin, lib, makeWrapper, vdr, plugins ? [] }:
+symlinkJoin {
+
+  name = "vdr-with-plugins-${(builtins.parseDrvName vdr.name).version}";
+
+  paths = [ vdr ] ++ plugins;
+
+  nativeBuildInputs = [ makeWrapper ];
+
+  postBuild = ''
+    wrapProgram $out/bin/vdr --add-flags "-L $out/lib/vdr --localedir=$out/share/locale"
+  '';
+
+  meta = with vdr.meta; {
+    inherit license homepage;
+    description = description
+    + " (with plugins: "
+    + lib.concatStrings (lib.intersperse ", " (map (x: ""+x.name) plugins))
+    + ")";
+  };
+}

pkgs/applications/virtualization/firecracker/default.nix

···
+{ fetchurl, stdenv }:
+
+let
+  version = "0.12.0";
+  baseurl = "https://github.com/firecracker-microvm/firecracker/releases/download";
+
+  fetchbin = name: sha256: fetchurl {
+    url    = "${baseurl}/v${version}/${name}-v${version}";
+    inherit sha256;
+  };
+
+  firecracker-bin = fetchbin "firecracker" "0jk9w5kagqp3w668c1x0g4yyahmy7696pm0bkhv066rrdpcqpw66";
+  jailer-bin      = fetchbin "jailer"      "1fcxzpnapnccklgbi4bis3f6c9fki2daxvzg9l7433vfqz2zbyjl";
+in
+stdenv.mkDerivation {
+  name = "firecracker-${version}";
+  inherit version;
+
+  srcs = [ firecracker-bin jailer-bin ];
+  phases = [ "installPhase" ];
+
+  installPhase = ''
+    mkdir -p $out/bin
+    install -D ${firecracker-bin} $out/bin/firecracker
+    install -D ${jailer-bin}      $out/bin/jailer
+  '';
+
+  meta = with stdenv.lib; {
+    description = "Secure, fast, minimal micro-container virtualization";
+    homepage    = http://firecracker-microvm.io;
+    license     = licenses.asl20;
+    platforms   = [ "x86_64-linux" ];
+    maintainers = with maintainers; [ thoughtpolice ];
+  };
+}

pkgs/applications/virtualization/runc/default.nix

···
-{ stdenv, lib, fetchFromGitHub, removeReferencesTo, go-md2man
-, go, pkgconfig, libapparmor, apparmor-parser, libseccomp }:
+{ stdenv, lib, fetchFromGitHub, buildGoPackage, go-md2man
+, pkgconfig, libapparmor, apparmor-parser, libseccomp, which }:
 
 with lib;
 
-stdenv.mkDerivation rec {
+buildGoPackage rec {
   name = "runc-${version}";
   version = "1.0.0-rc6";
 
···
     sha256 = "1jwacb8xnmx5fr86gximhbl9dlbdwj3rpf27hav9q1si86w5pb1j";
   };
 
-  outputs = [ "out" "man" ];
+  goPackagePath = "github.com/opencontainers/runc";
+  outputs = [ "bin" "out" "man" ];
 
   hardeningDisable = ["fortify"];
 
   nativeBuildInputs = [ pkgconfig ];
-  buildInputs = [ removeReferencesTo go-md2man go libseccomp libapparmor apparmor-parser ];
+  buildInputs = [ go-md2man libseccomp libapparmor apparmor-parser which ];
 
   makeFlags = ''BUILDTAGS+=seccomp BUILDTAGS+=apparmor'';
 
-  preConfigure = ''
-    # Extract the source
-    cd "$NIX_BUILD_TOP"
-    mkdir -p "go/src/github.com/opencontainers"
-    mv "$sourceRoot" "go/src/github.com/opencontainers/runc"
-    export GOPATH=$NIX_BUILD_TOP/go:$GOPATH
-  '';
-
-  preBuild = ''
-    cd go/src/github.com/opencontainers/runc
+  buildPhase = ''
+    cd go/src/${goPackagePath}
     patchShebangs .
     substituteInPlace libcontainer/apparmor/apparmor.go \
       --replace /sbin/apparmor_parser ${apparmor-parser}/bin/apparmor_parser
+    make ${makeFlags} runc
   '';
 
   installPhase = ''
-    install -Dm755 runc $out/bin/runc
+    install -Dm755 runc $bin/bin/runc
 
     # Include contributed man pages
     man/md2man-all.sh -q
···
         gzip -c "$manFile" > "$manRoot/$manBase/$manName.gz"
       done
     done
-  '';
-
-  preFixup = ''
-    find $out/bin -type f -exec remove-references-to -t ${go} '{}' +
   '';
 
   meta = {

pkgs/applications/window-managers/dwm/dwm-status.nix

···
 
 rustPlatform.buildRustPackage rec {
   name = "dwm-status-${version}";
-  version = "1.4.1";
+  version = "1.5.0";
 
   src = fetchFromGitHub {
     owner = "Gerschtli";
     repo = "dwm-status";
     rev = version;
-    sha256 = "054lwgqpx3kbrnlsqbnd8fxsawvw3nl702pf56c7dcm4sfws15nl";
+    sha256 = "0mfzpyacd7i6ipbjwyl1zc0x3lnz0f4qqzsmsb07p047z95mw4v6";
   };
 
   nativeBuildInputs = [ makeWrapper pkgconfig ];
   buildInputs = [ dbus gdk_pixbuf libnotify xorg.libX11 ];
 
-  cargoSha256 = "0wbbbk99hxxlrkm389iqni9aqvw2laarwk6hhwsr4ph3y278qhi8";
+  cargoSha256 = "1cngcacsbzijs55k4kz8fidki3p8jblk3v5s21hjsn4glzjdbkmm";
 
   postInstall = lib.optionalString enableAlsaUtils ''
-    wrapProgram $out/bin/dwm-status \
-      --prefix "PATH" : "${binPath}"
+    wrapProgram $out/bin/dwm-status --prefix "PATH" : "${binPath}"
   '';
 
   meta = with stdenv.lib; {

pkgs/applications/window-managers/yabar/unstable.nix

···
-{ playerctl, libxkbcommon, callPackage, attrs ? {} }:
+{ fetchpatch, playerctl, libxkbcommon, callPackage, attrs ? {} }:
 
 let
   pkg = callPackage ./build.nix ({
···
 
   makeFlags = o.makeFlags ++ [
     "PLAYERCTL=1"
+  ];
+
+  patches = (o.patches or []) ++ [
+    (fetchpatch {
+      url = "https://github.com/geommer/yabar/commit/008dc1420ff684cf12ce2ef3ac9d642e054e39f5.patch";
+      sha256 = "1q7nd66ai6nr2m6iqxn55gvbr4r5gjc00c8wyjc3riv31qcbqbhv";
+    })
   ];
 })

pkgs/data/fonts/source-sans-pro/default.nix

···
 { stdenv, fetchzip }:
 
 fetchzip {
-  name = "source-sans-pro-2.010";
+  name = "source-sans-pro-2.040";
 
-  url = "https://github.com/adobe-fonts/source-sans-pro/archive/2.010R-ro/1.065R-it.zip";
+  url = "https://github.com/adobe-fonts/source-sans-pro/releases/download/2.040R-ro%2F1.090R-it/source-sans-pro-2.040R-ro-1.090R-it.zip";
 
   postFetch = ''
-    mkdir -p $out/share/fonts/opentype
-    unzip -j $downloadedFile \*.otf -d $out/share/fonts/opentype
+    mkdir -p $out/share/fonts/opentype $out/share/fonts/truetype $out/share/fonts/variable
+    unzip -j $downloadedFile "*/OTF/*.otf" -d $out/share/fonts/opentype
+    unzip -j $downloadedFile "*/TTF/*.ttf" -d $out/share/fonts/truetype
+    unzip -j $downloadedFile "*/VAR/*.otf" -d $out/share/fonts/variable
   '';
 
-  sha256 = "17rgkh54arybmcdg750ynw32x2sps7p9vrvq9kpih8vdghwrh9k2";
+  sha256 = "1n7z9xpxls74xxjsa61df1ln86y063m07w1f4sbxpjaa0frim4pp";
 
   meta = with stdenv.lib; {
     homepage = https://sourceforge.net/adobe/sourcesans;

pkgs/desktops/gnome-3/core/evince/default.nix

···
 , librsvg, gobject-introspection, yelp-tools, gspell
 , recentListSize ? null # 5 is not enough, allow passing a different number
 , supportXPS ? false    # Open XML Paper Specification via libgxps
-, autoreconfHook
+, autoreconfHook, pruneLibtoolFiles
 }:
 
 stdenv.mkDerivation rec {
···
   };
 
   nativeBuildInputs = [
-    pkgconfig gobject-introspection intltool itstool wrapGAppsHook yelp-tools autoreconfHook
+    pkgconfig gobject-introspection intltool itstool wrapGAppsHook yelp-tools autoreconfHook pruneLibtoolFiles
   ];
 
   buildInputs = [

pkgs/desktops/gnome-3/core/gnome-software/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "gnome-software-${version}";
-  version = "3.30.5";
+  version = "3.30.6";
 
   src = fetchurl {
     url = "mirror://gnome/sources/gnome-software/${stdenv.lib.versions.majorMinor version}/${name}.tar.xz";
-    sha256 = "0d2x208qbkx8szkrfddv1bz4rd9awfhbxvh078j7zrrfmzvq7892";
+    sha256 = "00lh1ifgcs888i0774qdz2pzd5vnzcc5kvx20lcmgk37vvf0qqsl";
   };
 
   patches = [

pkgs/desktops/gnome-3/default.nix

···
 
 #### Misc -- other packages on http://ftp.gnome.org/pub/GNOME/sources/
 
-  california = callPackage ./misc/california { };
-
   geary = callPackage ./misc/geary { };
 
   gfbgraph = callPackage ./misc/gfbgraph { };

pkgs/desktops/gnome-3/misc/california/default.nix

···
-{ stdenv, fetchurl, intltool, pkgconfig, gtk3, vala_0_34, libgee, wrapGAppsHook, itstool, gobject-introspection
-, gnome-online-accounts, evolution-data-server, gnome3, glib, libsoup, libgdata, sqlite, xdg_utils }:
-
-let
-  pname = "california";
-  version = "0.4.0";
-in stdenv.mkDerivation rec {
-  name = "${pname}-${version}";
-
-  src = fetchurl {
-    url = "mirror://gnome/sources/${pname}/${stdenv.lib.versions.majorMinor version}/${name}.tar.xz";
-    sha256 = "1dky2kllv469k8966ilnf4xrr7z35pq8mdvs7kwziy59cdikapxj";
-  };
-
-  nativeBuildInputs = [ intltool itstool vala_0_34 pkgconfig wrapGAppsHook gobject-introspection ];
-  buildInputs = [ glib gtk3 libgee libsoup libgdata gnome-online-accounts evolution-data-server sqlite xdg_utils gnome3.gsettings-desktop-schemas ];
-
-  enableParallelBuilding = true;
-
-  patches = [
-    # Apply Fedora patch to build with evolution-data-server > 3.13
-    (fetchurl {
-      url = https://src.fedoraproject.org/rpms/california/raw/c00bf9924d8fa8cb0a9ec06564d1a1b00c9055af/f/0002-Build-with-evolution-data-server-3.13.90.patch;
-      sha256 = "0g9923n329p32gzr1q52ad30f8vyz8vrri4rih0w8klmf02ga4pm";
-    })
-    # Apply Fedora patch to build with libical > 3.0
-    (fetchurl {
-      url = https://src.fedoraproject.org/rpms/california/raw/2af9a6a1b67b53f3fca1472c5350dc11a1acf28f/f/california-0.4.0-libical-3.0.patch;
-      sha256 = "0cxycfaql0bsiz9hzanns33pwdqpb5n44znfcfa66i1bin34r4n6";
-    })
-  ];
-
-  passthru = {
-    updateScript = gnome3.updateScript {
-      packageName = pname;
-      attrPath = "gnome3.${pname}";
-    };
-  };
-
-  meta = with stdenv.lib; {
-    homepage = https://wiki.gnome.org/Apps/California;
-    description = "Calendar application for GNOME 3";
-    maintainers = with maintainers; [ pSub ];
-    license = licenses.lgpl21;
-    platforms = platforms.linux;
-  };
-}

pkgs/development/compilers/adoptopenjdk-bin/jdk11-darwin.nix

···
   jdk-hotspot = import ./jdk-darwin-base.nix sources.openjdk11.mac.jdk.hotspot;
   jre-hotspot = import ./jdk-darwin-base.nix sources.openjdk11.mac.jre.hotspot;
   jdk-openj9 = import ./jdk-darwin-base.nix sources.openjdk11.mac.jdk.openj9;
-  jre-openj9 = import ./jdk-darwin-base.nix sources.openjdk11.mac.jre.openj9;
+  # openj9 jre builds are currently missing: https://github.com/AdoptOpenJDK/openjdk-build/issues/796
+  #jre-openj9 = import ./jdk-darwin-base.nix sources.openjdk11.mac.jre.openj9;
 }

pkgs/development/compilers/chez/default.nix

···
     homepage    = https://cisco.github.io/ChezScheme/;
     license     = stdenv.lib.licenses.asl20;
     platforms   = stdenv.lib.platforms.unix;
+    badPlatforms = [ "aarch64-linux" ];
     maintainers = with stdenv.lib.maintainers; [ thoughtpolice ];
   };
 }

pkgs/development/compilers/llvm/4/libc++/default.nix

···
 
   linkCxxAbi = stdenv.isLinux;
 
+  postInstall = ''
+    mv $out/lib/libc++.a $out/lib/libc++_static.a
+    cp ${./libc++.a} $out/lib/libc++.a
+  '';
+
   setupHooks = [
     ../../../../../build-support/setup-hooks/role.bash
     ./setup-hook.sh

pkgs/development/compilers/llvm/4/libc++/libc++.a

···
+INPUT(-lc++_static -lc++abi)

pkgs/development/compilers/llvm/4/libc++abi.nix

···
     ''
     else ''
       install -d -m 755 $out/include $out/lib
+      install -m 644 lib/libc++abi.a $out/lib
       install -m 644 lib/libc++abi.so.1.0 $out/lib
       install -m 644 ../include/cxxabi.h $out/include
       ln -s libc++abi.so.1.0 $out/lib/libc++abi.so

pkgs/development/compilers/llvm/5/libc++/default.nix

···
 
   linkCxxAbi = stdenv.isLinux;
 
+  postInstall = ''
+    mv $out/lib/libc++.a $out/lib/libc++_static.a
+    cp ${./libc++.a} $out/lib/libc++.a
+  '';
+
   setupHooks = [
     ../../../../../build-support/setup-hooks/role.bash
     ./setup-hook.sh

pkgs/development/compilers/llvm/5/libc++/libc++.a

···
+INPUT(-lc++_static -lc++abi)

pkgs/development/compilers/llvm/5/libc++abi.nix

···
     ''
     else ''
       install -d -m 755 $out/include $out/lib
+      install -m 644 lib/libc++abi.a $out/lib
       install -m 644 lib/libc++abi.so.1.0 $out/lib
       install -m 644 ../include/cxxabi.h $out/include
       ln -s libc++abi.so.1.0 $out/lib/libc++abi.so

pkgs/development/compilers/llvm/6/libc++/default.nix

···
 
   linkCxxAbi = stdenv.isLinux;
 
+  postInstall = ''
+    mv $out/lib/libc++.a $out/lib/libc++_static.a
+    cp ${./libc++.a} $out/lib/libc++.a
+  '';
+
   setupHooks = [
     ../../../../../build-support/setup-hooks/role.bash
     ./setup-hook.sh

pkgs/development/compilers/llvm/6/libc++/libc++.a

···
+INPUT(-lc++_static -lc++abi)

pkgs/development/compilers/llvm/6/libc++abi.nix

···
     ''
     else ''
       install -d -m 755 $out/include $out/lib
+      install -m 644 lib/libc++abi.a $out/lib
       install -m 644 lib/libc++abi.so.1.0 $out/lib
       install -m 644 ../include/cxxabi.h $out/include
       ln -s libc++abi.so.1.0 $out/lib/libc++abi.so

pkgs/development/compilers/llvm/7/libc++/default.nix

···
 
   linkCxxAbi = stdenv.isLinux;
 
+  postInstall = ''
+    mv $out/lib/libc++.a $out/lib/libc++_static.a
+    cp ${./libc++.a} $out/lib/libc++.a
+  '';
+
   setupHooks = [
     ../../../../../build-support/setup-hooks/role.bash
     ./setup-hook.sh

pkgs/development/compilers/llvm/7/libc++/libc++.a

···
+INPUT(-lc++_static -lc++abi)

pkgs/development/compilers/llvm/7/libc++abi.nix

···
     ''
     else ''
       install -d -m 755 $out/include $out/lib
+      install -m 644 lib/libc++abi.a $out/lib
       install -m 644 lib/libc++abi.so.1.0 $out/lib
       install -m 644 ../include/cxxabi.h $out/include
       ln -s libc++abi.so.1.0 $out/lib/libc++abi.so

pkgs/development/compilers/mono/4.6.nix

···
-{ callPackage, Foundation, libobjc }:
-
-callPackage ./generic.nix (rec {
-  inherit Foundation libobjc;
-  version = "4.6.2.16";
-  sha256 = "190f7kcrm1y5x61s1xwdmjnwc3czsg50s3mml4xmix7byh3x2rc9";
-  enableParallelBuilding = false; # #32386, https://hydra.nixos.org/build/65617511
-  meta.knownVulnerabilities = [ "CVE-2018-1002208" ];
-})

pkgs/development/compilers/mono/4.8.nix pkgs/development/compilers/mono/4.nix

···
 { callPackage, Foundation, libobjc }:
 
-callPackage ./generic-cmake.nix (rec {
+callPackage ./generic.nix (rec {
   inherit Foundation libobjc;
   version = "4.8.1.0";
   sha256 = "1vyvp2g28ihcgxgxr8nhzyzdmzicsh5djzk8dk1hj5p5f2k3ijqq";

pkgs/development/compilers/mono/5.0.nix

···
-{ callPackage, Foundation, libobjc }:
-
-callPackage ./generic-cmake.nix (rec {
-  inherit Foundation libobjc;
-  version = "5.0.1.1";
-  sha256 = "064pgsmanpybpbhpam9jv9n8aicx6mlyb7a91yzh3kcksmqsxmj8";
-  enableParallelBuilding = false; # #32386, https://hydra.nixos.org/build/65820147
-})

pkgs/development/compilers/mono/5.14.nix

···
-{ callPackage, Foundation, libobjc }:
-
-callPackage ./generic-cmake.nix (rec {
-  inherit Foundation libobjc;
-  version = "5.14.0.177";
-  sha256 = "164l30fkvfgs1rh663h7dnm1yp7425bi9x2lh2y6zml8h4pgmxfl";
-  enableParallelBuilding = false;
-})

pkgs/development/compilers/mono/5.4.nix

···
-{ callPackage, Foundation, libobjc }:
-
-callPackage ./generic-cmake.nix (rec {
-  inherit Foundation libobjc;
-  version = "5.4.1.6";
-  sha256 = "1pv5lmyxjr8z9s17jx19850k43ylzqlbzsgr5jxj1knmkbza1zdx";
-  enableParallelBuilding = false; # #32386, https://hydra.nixos.org/build/65820147
-})

pkgs/development/compilers/mono/5.8.nix

···
-{ callPackage, Foundation, libobjc }:
-
-callPackage ./generic-cmake.nix (rec {
-  inherit Foundation libobjc;
-  version = "5.8.0.108";
-  sha256 = "177khb06dfll0pcncr84vvibni7f8m5fgb30ndgsdjk25xfcbmzc";
-  enableParallelBuilding = false;
-})

pkgs/development/compilers/mono/5.nix

···
+{ callPackage, Foundation, libobjc }:
+
+callPackage ./generic.nix (rec {
+  inherit Foundation libobjc;
+  version = "5.16.0.220";
+  sha256 = "1qwdmxssplfdb5rq86f1j8lskvr9dfk5c8hqz9ic09ml69r8c87l";
+  enableParallelBuilding = false;
+})

pkgs/development/compilers/mono/build-fix-llvm.patch

···
-diff --git a/lib/CodeGen/AsmPrinter/CMakeLists.txt.old b/lib/CodeGen/AsmPrinter/CMakeLists.txt
-index be484a6..c92ff46 100644
---- a/lib/CodeGen/AsmPrinter/CMakeLists.txt.old
-+++ b/lib/CodeGen/AsmPrinter/CMakeLists.txt
-@@ -10,6 +10,7 @@ add_llvm_library(LLVMAsmPrinter
-   DwarfCompileUnit.cpp
-   DwarfDebug.cpp
-   DwarfException.cpp
-+  DwarfMonoException.cpp
-   ErlangGCPrinter.cpp
-   OcamlGCPrinter.cpp
-   Win64Exception.cpp

pkgs/development/compilers/mono/generic-cmake.nix

···
-{ stdenv, fetchurl, bison, pkgconfig, glib, gettext, perl, libgdiplus, libX11, callPackage, ncurses, zlib, withLLVM ? false, cacert, Foundation, libobjc, python, version, sha256, autoconf, libtool, automake, cmake, which, enableParallelBuilding ? true }:
-
-let
-  llvm     = callPackage ./llvm.nix { };
-in
-stdenv.mkDerivation rec {
-  name = "mono-${version}";
-
-  src = fetchurl {
-    inherit sha256;
-    url = "https://download.mono-project.com/sources/mono/${name}.tar.bz2";
-  };
-
-  buildInputs =
-    [ bison pkgconfig glib gettext perl libgdiplus libX11 ncurses zlib python autoconf libtool automake cmake which
-    ]
-    ++ (stdenv.lib.optionals stdenv.isDarwin [ Foundation libobjc ]);
-
-  propagatedBuildInputs = [glib];
-
-  NIX_LDFLAGS = if stdenv.isDarwin then "" else "-lgcc_s" ;
-
-  # To overcome the bug https://bugzilla.novell.com/show_bug.cgi?id=644723
-  dontDisableStatic = true;
-
-  configureFlags = [
-    "--x-includes=${libX11.dev}/include"
-    "--x-libraries=${libX11.out}/lib"
-    "--with-libgdiplus=${libgdiplus}/lib/libgdiplus.so"
-  ]
-  ++ stdenv.lib.optionals withLLVM [
-    "--enable-llvm"
-    "--enable-llvmloaded"
-    "--with-llvm=${llvm}"
-  ];
-
-  configurePhase = ''
-    patchShebangs ./
-    ./autogen.sh --prefix $out $configureFlags
-  '';
-
-  # Attempt to fix this error when running "mcs --version":
-  # The file /nix/store/xxx-mono-2.4.2.1/lib/mscorlib.dll is an invalid CIL image
-  dontStrip = true;
-
-  # We want pkg-config to take priority over the dlls in the Mono framework and the GAC
-  # because we control pkg-config
-  patches = [ ./pkgconfig-before-gac.patch ];
-
-  # Patch all the necessary scripts. Also, if we're using LLVM, we fix the default
-  # LLVM path to point into the Mono LLVM build, since it's private anyway.
-  preBuild = ''
-    makeFlagsArray=(INSTALL=`type -tp install`)
-    substituteInPlace mcs/class/corlib/System/Environment.cs --replace /usr/share "$out/share"
-  '' + stdenv.lib.optionalString withLLVM ''
-    substituteInPlace mono/mini/aot-compiler.c --replace "llvm_path = g_strdup (\"\")" "llvm_path = g_strdup (\"${llvm}/bin/\")"
-  '';
-
-  # Fix mono DLLMap so it can find libX11 to run winforms apps
-  # libgdiplus is correctly handled by the --with-libgdiplus configure flag
-  # Other items in the DLLMap may need to be pointed to their store locations, I don't think this is exhaustive
-  # http://www.mono-project.com/Config_DllMap
-  postBuild = ''
-    find . -name 'config' -type f | xargs \
-    sed -i -e "[e-mail].6@${libX11.out}/lib/libX11.so.6@g"
-  '';
-
-  # Without this, any Mono application attempting to open an SSL connection will throw with
-  # The authentication or decryption has failed.
-  # ---> Mono.Security.Protocol.Tls.TlsException: Invalid certificate received from server.
-  postInstall = ''
-    echo "Updating Mono key store"
-    $out/bin/cert-sync ${cacert}/etc/ssl/certs/ca-bundle.crt
-  ''
-  # According to [1], gmcs is just mcs
-  # [1] https://github.com/mono/mono/blob/master/scripts/gmcs.in
-  + ''
-    ln -s $out/bin/mcs $out/bin/gmcs
-  '';
-
-  inherit enableParallelBuilding;
-
-  meta = with stdenv.lib; {
-    homepage = http://mono-project.com/;
-    description = "Cross platform, open source .NET development framework";
-    platforms = with platforms; darwin ++ linux;
-    maintainers = with maintainers; [ thoughtpolice obadz vrthra ];
-    license = licenses.free; # Combination of LGPL/X11/GPL ?
-  };
-}

pkgs/development/compilers/mono/generic.nix

···
-{ stdenv, fetchurl, bison, pkgconfig, glib, gettext, perl, libgdiplus, libX11
-, callPackage, ncurses, zlib
-, cacert, Foundation, libobjc, python
-
-, version, sha256
-, withLLVM ? false
-, enableParallelBuilding ? true
-, meta ? {}
-}:
+{ stdenv, fetchurl, bison, pkgconfig, glib, gettext, perl, libgdiplus, libX11, callPackage, ncurses, zlib, withLLVM ? false, cacert, Foundation, libobjc, python, version, sha256, autoconf, libtool, automake, cmake, which, enableParallelBuilding ? true }:
 
 let
   llvm     = callPackage ./llvm.nix { };
+in
+stdenv.mkDerivation rec {
   name = "mono-${version}";
-in
-stdenv.mkDerivation {
-  inherit name;
 
   src = fetchurl {
     inherit sha256;
···
   };
 
   buildInputs =
-    [ bison pkgconfig glib gettext perl libgdiplus libX11 ncurses zlib python
+    [ bison pkgconfig glib gettext perl libgdiplus libX11 ncurses zlib python autoconf libtool automake cmake which
     ]
     ++ (stdenv.lib.optionals stdenv.isDarwin [ Foundation libobjc ]);
 
···
   # To overcome the bug https://bugzilla.novell.com/show_bug.cgi?id=644723
   dontDisableStatic = true;
 
-  # In fact I think this line does not help at all to what I
-  # wanted to achieve: have mono to find libgdiplus automatically
   configureFlags = [
     "--x-includes=${libX11.dev}/include"
     "--x-libraries=${libX11.out}/lib"
···
   ]
   ++ stdenv.lib.optionals withLLVM [
     "--enable-llvm"
-    "--enable-llvmloaded"
     "--with-llvm=${llvm}"
   ];
 
+  configurePhase = ''
+    patchShebangs ./
+    ./autogen.sh --prefix $out $configureFlags
+  '';
+
   # Attempt to fix this error when running "mcs --version":
   # The file /nix/store/xxx-mono-2.4.2.1/lib/mscorlib.dll is an invalid CIL image
   dontStrip = true;
···
   # LLVM path to point into the Mono LLVM build, since it's private anyway.
   preBuild = ''
     makeFlagsArray=(INSTALL=`type -tp install`)
-    patchShebangs ./
     substituteInPlace mcs/class/corlib/System/Environment.cs --replace /usr/share "$out/share"
   '' + stdenv.lib.optionalString withLLVM ''
     substituteInPlace mono/mini/aot-compiler.c --replace "llvm_path = g_strdup (\"\")" "llvm_path = g_strdup (\"${llvm}/bin/\")"
   '';
 
-  # Fix mono DLLMap so it can find libX11 and gdiplus to run winforms apps
+  # Fix mono DLLMap so it can find libX11 to run winforms apps
+  # libgdiplus is correctly handled by the --with-libgdiplus configure flag
   # Other items in the DLLMap may need to be pointed to their store locations, I don't think this is exhaustive
   # http://www.mono-project.com/Config_DllMap
   postBuild = ''
     find . -name 'config' -type f | xargs \
-    sed -i -e "[e-mail].6@${libX11.out}/lib/libX11.so.6@g" \
-           -e "s@/.*libgdiplus.so@${libgdiplus}/lib/libgdiplus.so@g" \
+    sed -i -e "[e-mail].6@${libX11.out}/lib/libX11.so.6@g"
   '';
 
   # Without this, any Mono application attempting to open an SSL connection will throw with
···
 
   inherit enableParallelBuilding;
 
-  meta = {
+  meta = with stdenv.lib; {
     homepage = http://mono-project.com/;
     description = "Cross platform, open source .NET development framework";
-    platforms = stdenv.lib.platforms.x86;
-    maintainers = with stdenv.lib.maintainers; [ thoughtpolice obadz vrthra ];
-    license = stdenv.lib.licenses.free; # Combination of LGPL/X11/GPL ?
-  } // meta;
+    platforms = with platforms; darwin ++ linux;
+    maintainers = with maintainers; [ thoughtpolice obadz vrthra ];
+    license = licenses.free; # Combination of LGPL/X11/GPL ?
+  };
 }

pkgs/development/compilers/mono/llvm.nix

···
 { stdenv
-, fetchurl
-, perl
+, lib
+, fetchFromGitHub
 , groff
 , cmake
-, python
+, python2
+, perl
 , libffi
 , libbfd
 , libxml2
···
 
 stdenv.mkDerivation rec {
   name    = "llvm-${version}";
-  version = "3.4svn-mono-f9b1a74368";
-  src = fetchurl {
-    # from the HEAD of the 'mono3' branch
-    url = "https://github.com/mono/llvm/archive/f9b1a74368ec299fc04c4cfef4b5aa0992b7b806.tar.gz";
-    name = "${name}.tar.gz";
-    sha256 = "1bbkx4p5zdnk3nbdd5jxvbwqx8cdq8z1n1nhf639i98mggs0zhdg";
-  };
+  version = "3.6-mono-2017-02-15";
 
-  patches = [ ./build-fix-llvm.patch ];
-  unpackPhase = ''
-    unpackFile ${src}
-    mv llvm-* llvm
-    sourceRoot=$PWD/llvm
-  '';
+  src = fetchFromGitHub {
+    owner = "mono";
+    repo = "llvm";
+    rev = "dbb6fdffdeb780d11851a6be77c209bd7ada4bd3";
+    sha256 = "07wd1cs3fdvzb1lv41b655z5zk34f47j8fgd9ljjimi5j9pj71f7";
+  };
 
-  buildInputs = [ perl groff cmake libxml2 python libffi ] ++ stdenv.lib.optional stdenv.isLinux valgrind;
+  buildInputs = [ perl groff cmake libxml2 python2 libffi ] ++ lib.optional stdenv.isLinux valgrind;
 
   propagatedBuildInputs = [ ncurses zlib ];
 
···
   cmakeFlags = with stdenv; [
     "-DLLVM_ENABLE_FFI=ON"
     "-DLLVM_BINUTILS_INCDIR=${libbfd.dev}/include"
-    "-DCMAKE_CXX_FLAGS=-std=c++11"
   ] ++ stdenv.lib.optional (!isDarwin) "-DBUILD_SHARED_LIBS=ON";
 
   enableParallelBuilding = true;

pkgs/development/compilers/mono/pkgconfig-before-gac-5x.patch

···
-diff -Naur mono-5.0.0/mcs/tools/xbuild/data/3.5/Microsoft.Common.targets.old mono-5.0.0/mcs/tools/xbuild/data/3.5/Microsoft.Common.targets
---- mono-5.0.0/mcs/tools/xbuild/data/3.5/Microsoft.Common.targets.old	2017-04-24 23:45:18.348116305 +0200
-+++ mono-5.0.0/mcs/tools/xbuild/data/3.5/Microsoft.Common.targets	2017-04-24 23:45:11.407051755 +0200
-@@ -167,8 +167,8 @@
- 			$(ReferencePath);
- 			@(AdditionalReferencePath);
- 			{HintPathFromItem};
--			{TargetFrameworkDirectory};
- 			{PkgConfig};
-+			{TargetFrameworkDirectory};
- 			{GAC};
- 			{RawFileName};
- 			$(OutDir)
-diff -Naur mono-5.0.0/mcs/tools/xbuild/data/4.0/Microsoft.Common.targets.old mono-5.0.0/mcs/tools/xbuild/data/4.0/Microsoft.Common.targets
---- mono-5.0.0/mcs/tools/xbuild/data/4.0/Microsoft.Common.targets.old	2017-04-24 23:49:53.019616196 +0200
-+++ mono-5.0.0/mcs/tools/xbuild/data/4.0/Microsoft.Common.targets	2017-04-24 23:50:05.709729585 +0200
-@@ -232,8 +232,8 @@
- 			$(ReferencePath);
- 			@(AdditionalReferencePath);
- 			{HintPathFromItem};
--			{TargetFrameworkDirectory};
- 			{PkgConfig};
-+			{TargetFrameworkDirectory};
- 			{GAC};
- 			{RawFileName};
- 			$(OutDir)
-diff -Naur mono-5.0.0/mcs/tools/xbuild/data/2.0/Microsoft.Common.targets.old mono-5.0.0/mcs/tools/xbuild/data/2.0/Microsoft.Common.targets
---- mono-5.0.0/mcs/tools/xbuild/data/2.0/Microsoft.Common.targets.old	2017-04-24 23:52:33.200037047 +0200
-+++ mono-5.0.0/mcs/tools/xbuild/data/2.0/Microsoft.Common.targets	2017-04-24 23:52:43.281125802 +0200
-@@ -139,8 +139,8 @@
- 			$(ReferencePath);
- 			@(AdditionalReferencePath);
- 			{HintPathFromItem};
--			{TargetFrameworkDirectory};
- 			{PkgConfig};
-+			{TargetFrameworkDirectory};
- 			{GAC};
- 			{RawFileName};
- 			$(OutDir)
-diff -Naur mono-5.0.0/mcs/tools/xbuild/data/14.0/Microsoft.Common.targets.old mono-5.0.0/mcs/tools/xbuild/data/14.0/Microsoft.Common.targets
---- mono-5.0.0/mcs/tools/xbuild/data/14.0/Microsoft.Common.targets.old	2017-04-24 23:54:02.585821594 +0200
-+++ mono-5.0.0/mcs/tools/xbuild/data/14.0/Microsoft.Common.targets	2017-04-24 23:54:09.313880438 +0200
-@@ -234,8 +234,8 @@
- 			$(ReferencePath);
- 			@(AdditionalReferencePath);
- 			{HintPathFromItem};
--			{TargetFrameworkDirectory};
- 			{PkgConfig};
-+			{TargetFrameworkDirectory};
- 			{GAC};
- 			{RawFileName};
- 			$(OutDir)
-diff -Naur mono-5.0.0/mcs/tools/xbuild/data/12.0/Microsoft.Common.targets.old mono-5.0.0/mcs/tools/xbuild/data/12.0/Microsoft.Common.targets
---- mono-5.0.0/mcs/tools/xbuild/data/12.0/Microsoft.Common.targets.old	2017-04-24 23:55:46.244895155 +0200
-+++ mono-5.0.0/mcs/tools/xbuild/data/12.0/Microsoft.Common.targets	2017-04-24 23:55:51.998961342 +0200
-@@ -232,8 +232,8 @@
- 			$(ReferencePath);
- 			@(AdditionalReferencePath);
- 			{HintPathFromItem};
--			{TargetFrameworkDirectory};
- 			{PkgConfig};
-+			{TargetFrameworkDirectory};
- 			{GAC};
- 			{RawFileName};
- 			$(OutDir)

pkgs/development/compilers/mruby/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "mruby-${version}";
-  version = "1.4.1";
+  version = "2.0.0";
 
   src = fetchFromGitHub {
     owner   = "mruby";
     repo    = "mruby";
     rev     = version;
-    sha256  = "0pw72acbqgs4n1qa297nnja23v9hxz9g7190yfx9kwm7mgbllmww";
+    sha256  = "1r6w1asjshff43ymdwa6xmrkggza99mi2kw88k7ic6ag2j81hcj5";
   };
 
   patches = [

pkgs/development/compilers/solc/default.nix

···
 { stdenv, fetchzip, fetchFromGitHub, boost, cmake, z3 }:
 
 let
-  version = "0.5.1";
-  rev = "c8a2cb62832afb2dc09ccee6fd42c1516dfdb981";
-  sha256 = "0d6mfnixlr9m5yr3r4p6cv6vwrrivcamyar5d0f9rvir9w9ypzrr";
+  version = "0.5.2";
+  rev = "1df8f40cd2fd7b47698d847907b8ca7b47eb488d";
+  sha256 = "009kjyb3r2p64wpdzfcmqr9swm5haaixbzvsbw1nd4wipwbp66y0";
   jsoncppURL = https://github.com/open-source-parsers/jsoncpp/archive/1.8.4.tar.gz;
   jsoncpp = fetchzip {
     url = jsoncppURL;
···
   cmakeFlags = [
     "-DBoost_USE_STATIC_LIBS=OFF"
     "-DBUILD_SHARED_LIBS=ON"
-    "-DINSTALL_LLLC=ON"
   ];
 
   doCheck = stdenv.hostPlatform.isLinux && stdenv.hostPlatform == stdenv.buildPlatform;
-  checkPhase = "LD_LIBRARY_PATH=./libsolc:./libsolidity:./liblll:./libevmasm:./libdevcore:./libyul:./liblangutil:$LD_LIBRARY_PATH " +
+  checkPhase = "LD_LIBRARY_PATH=./libsolc:./libsolidity:./libevmasm:./libdevcore:./libyul:./liblangutil:$LD_LIBRARY_PATH " +
                "./test/soltest -p -- --no-ipc --no-smt --testpath ../test";
 
   nativeBuildInputs = [ cmake ];
···
 
   meta = with stdenv.lib; {
     description = "Compiler for Ethereum smart contract language Solidity";
-    longDescription = "This package also includes `lllc', the LLL compiler.";
     homepage = https://github.com/ethereum/solidity;
     license = licenses.gpl3;
     platforms = with platforms; linux ++ darwin;

pkgs/development/compilers/solc/patches/shared-libs-install.patch

···
 index 0c05208f..8893648e 100644
 --- a/CMakeLists.txt
 +++ b/CMakeLists.txt
-@@ -48,6 +48,25 @@ add_subdirectory(libevmasm)
+@@ -48,6 +48,22 @@ add_subdirectory(libevmasm)
  add_subdirectory(libsolidity)
  add_subdirectory(libsolc)
  
···
 +        FILES_MATCHING PATTERN "*.h")
 +install(DIRECTORY liblangutil/
 +        DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/liblangutil
-+        FILES_MATCHING PATTERN "*.h")
-+install(DIRECTORY liblll/
-+        DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/liblll
 +        FILES_MATCHING PATTERN "*.h")
 +
  if (NOT EMSCRIPTEN)
···
  add_library(evmasm ${sources} ${headers})
  target_link_libraries(evmasm PUBLIC devcore)
 +install(TARGETS evmasm LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR})
-diff --git a/liblll/CMakeLists.txt b/liblll/CMakeLists.txt
-index 4cdc073a..b61f03c7 100644
---- a/liblll/CMakeLists.txt
-+++ b/liblll/CMakeLists.txt
-@@ -3,3 +3,4 @@ file(GLOB headers "*.h")
- 
- add_library(lll ${sources} ${headers})
- target_link_libraries(lll PUBLIC evmasm devcore)
-+install(TARGETS lll LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR})
 diff --git a/libsolidity/CMakeLists.txt b/libsolidity/CMakeLists.txt
 index 0bdec4b4..e876177e 100644
 --- a/libsolidity/CMakeLists.txt
···
    target_link_libraries(solidity PUBLIC ${Z3_LIBRARY})
 --- a/libyul/CMakeLists.txt
 +++ b/libyul/CMakeLists.txt
-@@ -42,3 +42,4 @@ endif()
+@@ -43,3 +43,4 @@ endif()
  	optimiser/VarDeclPropagator.cpp
  )
--target_link_libraries(yul PUBLIC devcore)
-+target_link_libraries(yul PUBLIC evmasm devcore langutil)
+ target_link_libraries(yul PUBLIC evmasm devcore langutil)
 +install(TARGETS yul LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR})
 --- a/liblangutil/CMakeLists.txt
 +++ b/liblangutil/CMakeLists.txt

pkgs/development/compilers/vala/default.nix

···
   };
 
 in rec {
-  vala_0_34 = generic {
-    major   = "0.34";
-    minor   = "18";
-    sha256  = "1lhw3ghns059y5d6pdldy5p4yjwlhcls84k892i6qmbhxg34945q";
-  };
-
   vala_0_36 = generic {
     major   = "0.36";
     minor   = "17";

pkgs/development/coq-modules/Cheerios/default.nix

···
 { stdenv, fetchFromGitHub, coq, StructTact }:
 
-let params =
+let param =
   {
-    "8.6" = {
-      version = "20181102";
-      rev = "04da309304bdd28a1f7dacca9fdf8696204a4ff2";
-      sha256 = "1xfa78p70c90favds1mv1vj5sr9bv0ad3dsgg05v3v72006g2f1q";
-    };
-
-    "8.7" = {
       version = "20181102";
       rev = "04da309304bdd28a1f7dacca9fdf8696204a4ff2";
       sha256 = "1xfa78p70c90favds1mv1vj5sr9bv0ad3dsgg05v3v72006g2f1q";
-    };
-
-    "8.8" = {
-      version = "20181102";
-      rev = "04da309304bdd28a1f7dacca9fdf8696204a4ff2";
-      sha256 = "1xfa78p70c90favds1mv1vj5sr9bv0ad3dsgg05v3v72006g2f1q";
-    };
-
-    "8.9" = {
-      version = "20181102";
-      rev = "04da309304bdd28a1f7dacca9fdf8696204a4ff2";
-      sha256 = "1xfa78p70c90favds1mv1vj5sr9bv0ad3dsgg05v3v72006g2f1q";
-    };
   };
-  param = params."${coq.coq-version}";
 in
 
 stdenv.mkDerivation rec {
···
     inherit (param) rev sha256;
   };
 
-  buildInputs = [
-    coq coq.ocaml coq.camlp5 coq.findlib StructTact
-  ];
+  buildInputs = [ coq ];
+
+  propagatedBuildInputs = [ StructTact ];
   enableParallelBuilding = true;
 
-  buildPhase = "make -j$NIX_BUILD_CORES";
+  preConfigure = "patchShebangs ./configure";
+
   installFlags = "COQLIB=$(out)/lib/coq/${coq.coq-version}/";
 
   passthru = {
-    compatibleCoqVersions = v: builtins.elem v [ "8.6" "8.7" "8.8" "8.9" ];
+    compatibleCoqVersions = v: stdenv.lib.versionAtLeast v "8.6";
  };
 }

pkgs/development/coq-modules/InfSeqExt/default.nix

···
-{ stdenv, fetchFromGitHub, coq, mathcomp }:
+{ stdenv, fetchFromGitHub, coq }:
 
-let params =
+let param =
   {
-    "8.5" = {
-      version = "20180918";
-      rev = "243d6be45666da73a9da6c37d451327165275798";
-      sha256 = "1nh2psb4pcppy1akk24ilb4p08m35cba357i4xyymmarmbwqpxmn";
-    };
-
-    "8.6" = {
       version = "20180918";
       rev = "243d6be45666da73a9da6c37d451327165275798";
       sha256 = "1nh2psb4pcppy1akk24ilb4p08m35cba357i4xyymmarmbwqpxmn";
-    };
-
-    "8.7" = {
-      version = "20180918";
-      rev = "243d6be45666da73a9da6c37d451327165275798";
-      sha256 = "1nh2psb4pcppy1akk24ilb4p08m35cba357i4xyymmarmbwqpxmn";
-    };
-
-    "8.8" = {
-      version = "20180918";
-      rev = "243d6be45666da73a9da6c37d451327165275798";
-      sha256 = "1nh2psb4pcppy1akk24ilb4p08m35cba357i4xyymmarmbwqpxmn";
-    };
-
-    "8.9" = {
-      version = "20180918";
-      rev = "243d6be45666da73a9da6c37d451327165275798";
-      sha256 = "1nh2psb4pcppy1akk24ilb4p08m35cba357i4xyymmarmbwqpxmn";
-    };
   };
-  param = params."${coq.coq-version}";
 in
 
 stdenv.mkDerivation rec {
···
     inherit (param) rev sha256;
   };
 
-  buildInputs = [
-    coq coq.ocaml coq.camlp5 coq.findlib mathcomp
-  ];
+  buildInputs = [ coq ];
+
   enableParallelBuilding = true;
 
-  buildPhase = "make -j$NIX_BUILD_CORES";
+  preConfigure = "patchShebangs ./configure";
+
   installFlags = "COQLIB=$(out)/lib/coq/${coq.coq-version}/";
 
   passthru = {
-    compatibleCoqVersions = v: builtins.elem v [ "8.5" "8.6" "8.7" "8.8" "8.9" ];
+    compatibleCoqVersions = v: stdenv.lib.versionAtLeast v "8.5";
  };
 }

pkgs/development/coq-modules/StructTact/default.nix

···
 { stdenv, fetchFromGitHub, coq, mathcomp }:
 
-let params =
+let param =
   {
-    "8.5" = {
       version = "20181102";
       rev = "82a85b7ec07e71fa6b30cfc05f6a7bfb09ef2510";
       sha256 = "08zry20flgj7qq37xk32kzmg4fg6d4wi9m7pf9aph8fd3j2a0b5v";
-    };
-
-    "8.6" = {
-      version = "20181102";
-      rev = "82a85b7ec07e71fa6b30cfc05f6a7bfb09ef2510";
-      sha256 = "08zry20flgj7qq37xk32kzmg4fg6d4wi9m7pf9aph8fd3j2a0b5v";
-    };
-
-    "8.7" = {
-      version = "20181102";
-      rev = "82a85b7ec07e71fa6b30cfc05f6a7bfb09ef2510";
-      sha256 = "08zry20flgj7qq37xk32kzmg4fg6d4wi9m7pf9aph8fd3j2a0b5v";
-    };
-
-    "8.8" = {
-      version = "20181102";
-      rev = "82a85b7ec07e71fa6b30cfc05f6a7bfb09ef2510";
-      sha256 = "08zry20flgj7qq37xk32kzmg4fg6d4wi9m7pf9aph8fd3j2a0b5v";
-    };
-
-    "8.9" = {
-      version = "20181102";
-      rev = "82a85b7ec07e71fa6b30cfc05f6a7bfb09ef2510";
-      sha256 = "08zry20flgj7qq37xk32kzmg4fg6d4wi9m7pf9aph8fd3j2a0b5v";
-    };
   };
-  param = params."${coq.coq-version}";
 in
 
 stdenv.mkDerivation rec {
···
     inherit (param) rev sha256;
   };
 
-  buildInputs = [
-    coq coq.ocaml coq.camlp5 coq.findlib
-  ];
+  buildInputs = [ coq ];
+
   enableParallelBuilding = true;
 
-  buildPhase = "make -j$NIX_BUILD_CORES";
+  preConfigure = "patchShebangs ./configure";
+
   installFlags = "COQLIB=$(out)/lib/coq/${coq.coq-version}/";
 
   passthru = {
-    compatibleCoqVersions = v: builtins.elem v [ "8.5" "8.6" "8.7" "8.8" "8.9" ];
+    compatibleCoqVersions = v: stdenv.lib.versionAtLeast v "8.5";
  };
 }

pkgs/development/coq-modules/Verdi/default.nix

···
-{ stdenv, fetchFromGitHub, coq, mathcomp, StructTact, InfSeqExt, Cheerios }:
+{ stdenv, fetchFromGitHub, coq, Cheerios, InfSeqExt, ssreflect }:
 
-let params =
+let param =
   {
-    "8.6" = {
       version = "20181102";
       rev = "25b79cf1be5527ab8dc1b8314fcee93e76a2e564";
       sha256 = "1vw47c37k5vaa8vbr6ryqy8riagngwcrfmb3rai37yi9xhdqg55z";
-    };
-
-    "8.7" = {
-      version = "20181102";
-      rev = "25b79cf1be5527ab8dc1b8314fcee93e76a2e564";
-      sha256 = "1vw47c37k5vaa8vbr6ryqy8riagngwcrfmb3rai37yi9xhdqg55z";
-    };
-
-    "8.8" = {
-      version = "20181102";
-      rev = "25b79cf1be5527ab8dc1b8314fcee93e76a2e564";
-      sha256 = "1vw47c37k5vaa8vbr6ryqy8riagngwcrfmb3rai37yi9xhdqg55z";
-    };
-
-    "8.9" = {
-      version = "20181102";
-      rev = "25b79cf1be5527ab8dc1b8314fcee93e76a2e564";
-      sha256 = "1vw47c37k5vaa8vbr6ryqy8riagngwcrfmb3rai37yi9xhdqg55z";
-    };
   };
-  param = params."${coq.coq-version}";
 in
 
 stdenv.mkDerivation rec {
···
     inherit (param) rev sha256;
   };
 
-  buildInputs = [
-    coq coq.ocaml coq.camlp5 coq.findlib mathcomp StructTact InfSeqExt Cheerios
-  ];
+  buildInputs = [ coq ];
+  propagatedBuildInputs = [ Cheerios InfSeqExt ssreflect ];
+
   enableParallelBuilding = true;
 
-  buildPhase = "make -j$NIX_BUILD_CORES";
+  preConfigure = "patchShebangs ./configure";
+
   installFlags = "COQLIB=$(out)/lib/coq/${coq.coq-version}/";
 
   passthru = {
-    compatibleCoqVersions = v: builtins.elem v [ "8.6" "8.7" "8.8" "8.9" ];
+    compatibleCoqVersions = v: stdenv.lib.versionAtLeast v "8.6";
  };
 }

pkgs/development/coq-modules/coqprime/default.nix

···
 { stdenv, fetchFromGitHub, coq, bignums }:
 
 let params =
+  let v_8_8 = {
+      version = "8.8";
+      sha256 = "075yjczk79pf1hd3lgdjiz84ilkzfxjh18lgzrhhqp7d3kz5lxp5";
+    };
+  in
   {
     "8.7" = {
       version = "8.7.2";
       sha256 = "15zlcrx06qqxjy3nhh22wzy0rb4npc8l4nx2bbsfsvrisbq1qb7k";
     };
-    "8.8" = {
-      version = "8.8";
-      sha256 = "075yjczk79pf1hd3lgdjiz84ilkzfxjh18lgzrhhqp7d3kz5lxp5";
+    "8.8" = v_8_8;
+    "8.9" = v_8_8;
     };
-  };
   param = params."${coq.coq-version}"
 ; in
 

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

···
   # https://github.com/mgajda/json-autotype/issues/25
   json-autotype = dontCheck super.json-autotype;
 
-  # https://github.com/kazu-yamamoto/iproute/issues/43
-  appar = self.appar_0_1_7;
-
   # The LTS-12.x version doesn't suffice to build hlint, hoogle, etc.
   hlint = super.hlint.overrideScope (self: super: { haskell-src-exts = self.haskell-src-exts_1_21_0; });
   hoogle = super.hoogle.overrideScope (self: super: { haskell-src-exts = self.haskell-src-exts_1_21_0; });

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

···
   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_6_0;
-  JuicyPixels = self.JuicyPixels_3_3_2;
+  JuicyPixels = self.JuicyPixels_3_3_3;
   lens = self.lens_4_17;
   megaparsec = dontCheck (doJailbreak super.megaparsec);
   pandoc = self.pandoc_2_5;

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

···
 
 default-package-overrides:
   # Newer versions don't work in LTS-12.x
+  - alsa-mixer < 0.3
   - cassava-megaparsec < 2
-  # LTS Haskell 12.22
+  # LTS Haskell 12.23
   - abstract-deque ==0.3
   - abstract-deque-tests ==0.3
   - abstract-par ==0.3.3
···
   - alarmclock ==0.5.0.2
   - alerts ==0.1.0.0
   - alex ==3.2.4
-  - alg ==0.2.8.0
+  - alg ==0.2.9.0
   - algebra ==4.3.1
   - algebraic-graphs ==0.2
   - Allure ==0.8.3.0
···
   - ansi-wl-pprint ==0.6.8.2
   - ANum ==0.2.0.2
   - api-field-json-th ==0.1.0.2
-  - appar ==0.1.5
+  - appar ==0.1.7
   - apply-refact ==0.5.0.0
   - apportionment ==0.0.0.3
   - approximate ==0.3.1
···
   - blake2 ==0.2.0
   - blank-canvas ==0.6.3
   - blas-carray ==0.0.1.1
-  - blas-ffi ==0.0.1.1
+  - blas-ffi ==0.0.2
   - blas-hs ==0.1.1.0
   - blaze-bootstrap ==0.1.0.1
   - blaze-builder ==0.4.1.0
···
   - exp-pairs ==0.1.6.0
   - extensible ==0.4.9
   - extensible-exceptions ==0.1.1.4
-  - extra ==1.6.13
+  - extra ==1.6.14
   - extractable-singleton ==0.0.1
   - extrapolate ==0.3.3
   - facts ==0.0.1.0
···
   - fileplow ==0.1.0.0
   - filter-logger ==0.6.0.0
   - filtrable ==0.1.1.0
+  - Fin ==0.2.6.1
   - fin ==0.0.1
-  - Fin ==0.2.6.0
   - FindBin ==0.0.5
   - find-clumpiness ==0.2.3.1
   - fingertree ==0.1.4.2
···
   - GLUT ==2.7.0.14
   - gnuplot ==0.5.5.3
   - goggles ==0.3.2
-  - google-oauth2-jwt ==0.3.0
+  - google-oauth2-jwt ==0.3.1
   - gpolyline ==0.1.0.1
   - graph-core ==0.3.0.0
   - graphs ==0.7.1
   - graphviz ==2999.20.0.2
-  - graph-wrapper ==0.2.5.1
+  - graph-wrapper ==0.2.5.2
   - gravatar ==0.8.0
   - graylog ==0.1.0.1
   - greskell ==0.2.2.0
···
   - hapistrano ==0.3.7.0
   - happstack-server ==7.5.1.1
   - happy ==1.19.9
-  - hasbolt ==0.1.3.1
+  - hasbolt ==0.1.3.2
   - hashable ==1.2.7.0
   - hashids ==1.0.2.4
   - hashing ==0.1.0.1
···
   - iff ==0.0.6
   - ihaskell ==0.9.1.0
   - ihaskell-hvega ==0.1.0.3
-  - ihs ==0.1.0.2
+  - ihs ==0.1.0.3
   - ilist ==0.3.1.0
   - imagesize-conduit ==1.1
   - Imlib ==0.1.2
···
   - invariant ==0.5.1
   - invertible ==0.2.0.5
   - invertible-grammar ==0.1.1
-  - io-choice ==0.0.6
+  - io-choice ==0.0.7
   - io-machine ==0.2.0.0
   - io-manager ==0.1.0.2
   - io-memoize ==1.1.1.0
···
   - io-streams-haproxy ==1.0.0.2
   - ip ==1.3.0
   - ip6addr ==1.0.0
-  - iproute ==1.7.6
+  - iproute ==1.7.7
   - IPv6Addr ==1.1.1
   - IPv6DB ==0.3.1
   - ipython-kernel ==0.9.1.0
···
   - median-stream ==0.7.0.0
   - med-module ==0.1.1
   - megaparsec ==6.5.0
-  - mega-sdist ==0.3.3.1
+  - mega-sdist ==0.3.3.2
   - memory ==0.14.18
   - MemoTrie ==0.6.9
   - mercury-api ==0.1.0.1
···
   - refined ==0.2.3.0
   - reflection ==2.1.4
   - RefSerialize ==0.4.0
+  - regex ==1.0.1.4
   - regex-applicative ==0.3.3
   - regex-applicative-text ==0.1.0.1
   - regex-base ==0.93.2
···
   - say ==0.1.0.1
   - sbp ==2.3.17
   - sbv ==7.12
-  - scalendar ==1.2.0
   - SCalendar ==1.1.0
+  - scalendar ==1.2.0
   - scalpel ==0.5.1
   - scalpel-core ==0.5.1
   - scanner ==0.2
···
   - shell-escape ==0.2.0
   - shelltestrunner ==1.9
   - shelly ==1.8.1
-  - shortcut-links ==0.4.2.0
+  - shortcut-links ==0.4.2.1
   - should-not-typecheck ==2.1.0
   - show-combinators ==0.1.0.0
   - show-prettyprint ==0.2.2
···
   - unix-bytestring ==0.3.7.3
   - unix-compat ==0.5.1
   - unix-time ==0.3.8
-  - unliftio ==0.2.8.1
+  - unliftio ==0.2.9.0
   - unliftio-core ==0.1.2.0
   - unlit ==0.4.0.0
   - unordered-containers ==0.2.9.0
···
   - word-wrap ==0.4.1
   - world-peace ==0.1.0.0
   - wrap ==0.0.0
-  - wreq ==0.5.3.0
+  - wreq ==0.5.3.1
   - wreq-stringless ==0.5.9.1
   - writer-cps-full ==0.1.0.0
   - writer-cps-lens ==0.1.0.1

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

···
        pname = "Euterpea";
        version = "2.0.6";
        sha256 = "0smaa34s0yz90q4qx104glyx8s93k6vn6r60m6aq9infm7rkffxw";
+       revision = "1";
+       editedCabalFile = "1yrr18wv22ri1v8mij4lazl5lpri7sf8bxbz7igsbs8dngmycn9r";
        libraryHaskellDepends = [
          array arrows base bytestring containers deepseq ghc-prim HCodecs
          heap PortMidi random stm
···
      }:
      mkDerivation {
        pname = "Fin";
-       version = "0.2.6.0";
-       sha256 = "18qc3ih3l9zd13knxxsh657iq3c742pfaz4i45bq1ir60qwjqmhw";
-       libraryHaskellDepends = [
-         alg base foldable1 natural-induction peano universe-base
-       ];
-       description = "Finite totally-ordered sets";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "Fin_0_2_6_1" = callPackage
-    ({ mkDerivation, alg, base, foldable1, natural-induction, peano
-     , universe-base
-     }:
-     mkDerivation {
-       pname = "Fin";
        version = "0.2.6.1";
        sha256 = "15r5cvxwwbp7d6fmkfkzg65kzwf5v4j3rf84a5qsw900i4c05cmx";
        libraryHaskellDepends = [
···
        ];
        description = "Finite totally-ordered sets";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "Finance-Quote-Yahoo" = callPackage
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "Glob_0_10_0" = callPackage
+    ({ mkDerivation, base, containers, directory, dlist, filepath
+     , HUnit, QuickCheck, test-framework, test-framework-hunit
+     , test-framework-quickcheck2, transformers, transformers-compat
+     }:
+     mkDerivation {
+       pname = "Glob";
+       version = "0.10.0";
+       sha256 = "0953f91f62ncna402vsrfzdcyxhdpjna3bgdw017kad0dfymacs7";
+       libraryHaskellDepends = [
+         base containers directory dlist filepath transformers
+         transformers-compat
+       ];
+       testHaskellDepends = [
+         base containers directory dlist filepath HUnit QuickCheck
+         test-framework test-framework-hunit test-framework-quickcheck2
+         transformers transformers-compat
+       ];
+       description = "Globbing library";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "GlomeTrace" = callPackage
     ({ mkDerivation, array, base, GlomeVec }:
      mkDerivation {
···
      }) {inherit (pkgs) unixODBC;};
 
   "HDBC-postgresql" = callPackage
-    ({ mkDerivation, base, bytestring, Cabal, convertible, HDBC, mtl
-     , old-time, parsec, postgresql, time, utf8-string
+    ({ mkDerivation, base, bytestring, convertible, HDBC, mtl, old-time
+     , parsec, postgresql, time, utf8-string
      }:
      mkDerivation {
        pname = "HDBC-postgresql";
-       version = "2.3.2.5";
-       sha256 = "0l9i7mkdcch7f1ajl0fma7rra3dc0llmlia0iqhqb4k0gcrpy7l8";
-       revision = "1";
-       editedCabalFile = "1myhqsn3kk21pchlwf9s6vxggl59s6vmhmbx2539ad4jvnfy2ijx";
+       version = "2.3.2.6";
+       sha256 = "1kas80zv3vbqq9cd73w87fj4mwxcphfmf7ycfnl4jwdzpqjzr0yj";
        isLibrary = true;
        isExecutable = true;
-       setupHaskellDepends = [ base Cabal ];
        libraryHaskellDepends = [
          base bytestring convertible HDBC mtl old-time parsec time
          utf8-string
···
     ({ mkDerivation, array, base, containers, random }:
      mkDerivation {
        pname = "HaskellForMaths";
-       version = "0.4.8";
-       sha256 = "0yn2nj6irmj24j1djvnnq26i2lbf9g9x1wdhmcrk519glcn5k64j";
+       version = "0.4.9";
+       sha256 = "1jgim9g0jbv6k31aalq0yps843jmfx74k53lnd1p79kgad7670rz";
        libraryHaskellDepends = [ array base containers random ];
        description = "Combinatorics, group theory, commutative algebra, non-commutative algebra";
        license = stdenv.lib.licenses.bsd3;
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "JuicyPixels_3_3_2" = callPackage
+  "JuicyPixels_3_3_3" = callPackage
     ({ mkDerivation, base, binary, bytestring, containers, deepseq, mtl
      , primitive, transformers, vector, zlib
      }:
      mkDerivation {
        pname = "JuicyPixels";
-       version = "3.3.2";
-       sha256 = "120jlrqwa7i32yddwbyl6iyx99gx1fvrizb5lybj87p4fr7cxj6z";
+       version = "3.3.3";
+       sha256 = "1i5k81nfgibbmf5f70iicbh8rqbng61r926wcf9hwy2aa2vba11c";
+       revision = "1";
+       editedCabalFile = "1q8xyxn1a4ldaa1grmr7dywdbf4vqjw65v52h6z7ssz12hgjx0gq";
        libraryHaskellDepends = [
          base binary bytestring containers deepseq mtl primitive
          transformers vector zlib
···
     ({ mkDerivation, array, base, Cabal }:
      mkDerivation {
        pname = "KMP";
-       version = "0.1.0.2";
-       sha256 = "14dpqfji00jq2rc09l8d1ivphpiwkryjk5sn6lrwxv8mcly3pvhn";
+       version = "0.2.0.0";
+       sha256 = "0x90yi4aplfqhwaaw5ymgcmv6fpg7659r8n7ir6xfkrpgfmk18i9";
        libraryHaskellDepends = [ array base ];
        testHaskellDepends = [ base Cabal ];
        description = "Knuth–Morris–Pratt string searching algorithm";
···
      }:
      mkDerivation {
        pname = "Plot-ho-matic";
-       version = "0.12.2.2";
-       sha256 = "07zxn4gqkmprrpfyd8vvsf4c2350965k029nzvs0zvrwfbkxin4m";
+       version = "0.12.2.3";
+       sha256 = "1wmylc6z8ikq2qky46jvzffrrjzl8c9xzzlkwsx8223cxa2n59pn";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "Rasterific_0_7_4_1" = callPackage
+  "Rasterific_0_7_4_2" = callPackage
     ({ mkDerivation, base, bytestring, containers, dlist, FontyFruity
      , free, JuicyPixels, mtl, primitive, transformers, vector
      , vector-algorithms
      }:
      mkDerivation {
        pname = "Rasterific";
-       version = "0.7.4.1";
-       sha256 = "1d0j7xf2xbgrlny30qwm52wby51ic2cqlhb867a7a03k02p7ib2b";
-       revision = "1";
-       editedCabalFile = "1lz8b9xcfcv0a762zvaksh7c80yryc9yhap198dlm60i0znpjdg2";
+       sha256 = "0693ca7rwai4s8i8vqbmmq3q50pd23svcnnnd1cxjbqxh6hgsbs1";
+       sha256 = "1sg63cvcb64gbrxkn5pgs1nvvb1c9qfya7xxwn5daqpjgan426w1";
        libraryHaskellDepends = [
          base bytestring containers dlist FontyFruity free JuicyPixels mtl
          primitive transformers vector vector-algorithms
···
        pname = "SVGFonts";
        version = "1.7";
        sha256 = "1k9ili7l9pp5a009jh55vigb917wdnsl6iaz0ggp6d4nw1jwsg6s";
+       revision = "1";
+       editedCabalFile = "1w687f4lk4l07wqgldhpg7ycid0fs099x8vrylcxqdgfrzmm04dg";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          attoparsec base blaze-markup blaze-svg bytestring cereal
···
        pname = "aeson-extra";
        version = "0.4.1.1";
        sha256 = "1y7xss382hdxrv4jzprsm3b7ij7wiw8jgjg9wp49dx6bfvcnb2nl";
-       revision = "2";
-       editedCabalFile = "1iiibpr8pcdr0bjp0rhf1sxvs0kv66jm01nwlhj4243864qx476r";
+       revision = "3";
+       editedCabalFile = "0b9ccv529msmqay0gw2xcxm67n08hmv6s45ivyd8vq0rig4wz407";
        libraryHaskellDepends = [
          aeson aeson-compat attoparsec attoparsec-iso8601 base
          base-compat-batteries bytestring containers deepseq exceptions
···
     ({ mkDerivation, base, util }:
      mkDerivation {
        pname = "alg";
-       version = "0.2.8.0";
-       sha256 = "1zw50da4wz8qdc62qlvg74k3g5n48xlzda2k7c3y9zb8xb2xbfrr";
-       libraryHaskellDepends = [ base util ];
-       description = "Algebraic structures";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "alg_0_2_9_0" = callPackage
-    ({ mkDerivation, base, util }:
-     mkDerivation {
-       pname = "alg";
        version = "0.2.9.0";
        sha256 = "0w5lxmz52nskh8ms3nliya78v1pb77f7nyn19klqf8yskaalywlq";
        libraryHaskellDepends = [ base util ];
        description = "Algebraic structures";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "alga" = callPackage
···
     ({ mkDerivation, alsa-core, alsaLib, base, c2hs, unix }:
      mkDerivation {
        pname = "alsa-mixer";
+       version = "0.2.0.3";
+       sha256 = "13fgd78msqsyzm92cbasm8m3s1rww6r1g83qbrv4mkm2h50fnvgp";
+       libraryHaskellDepends = [ alsa-core base unix ];
+       librarySystemDepends = [ alsaLib ];
+       libraryToolDepends = [ c2hs ];
+       description = "Bindings to the ALSA simple mixer API";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
+     }) {inherit (pkgs) alsaLib;};
+
+  "alsa-mixer_0_3_0" = callPackage
+    ({ mkDerivation, alsa-core, alsaLib, base, c2hs, unix }:
+     mkDerivation {
+       pname = "alsa-mixer";
        version = "0.3.0";
        sha256 = "00ny2p3276jilidjs44npc8zmbhynz3f2lpmlwwl6swwx5yijsnb";
        libraryHaskellDepends = [ alsa-core base unix ];
···
        libraryToolDepends = [ c2hs ];
        description = "Bindings to the ALSA simple mixer API";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {inherit (pkgs) alsaLib;};
 
   "alsa-pcm" = callPackage
···
      }:
      mkDerivation {
        pname = "amqp-worker";
-       version = "0.2.4";
-       sha256 = "0ps0d9hly3cc9y7cmi5gr6p3h8qddig7sz3s7v6dl0icy3bvhinc";
+       version = "0.2.5";
+       sha256 = "0crbrmxwv1dwd84l41p2zmx5ap5wwr0n5a9cznz87x3cc6qncylq";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "antiope-athena";
-       version = "6.1.5";
-       sha256 = "0p78yxdnfzz6jw7az6xfh6sjcnf9d8sl512cmhdcws78p7f2rhlx";
+       version = "6.2.0";
+       sha256 = "0kd31s399rddcjj8ayvki85j66xlkb7gh0jgfwxmxcxp3x4gs0xi";
        libraryHaskellDepends = [
          amazonka amazonka-athena amazonka-core base lens resourcet text
          unliftio-core
···
     ({ mkDerivation, aeson, antiope-s3, avro, base, bytestring, text }:
      mkDerivation {
        pname = "antiope-contract";
-       version = "6.1.5";
-       sha256 = "1ikd0sn3z901hyad55ngzs99b0v9bs5vkry5965w22smljdg3rqh";
+       version = "6.2.0";
+       sha256 = "0s2s0vq6n7zwjj1yd7kmpwxkvbnfd2ikjv9nzg1rz0hm6mz1dn4p";
        libraryHaskellDepends = [
          aeson antiope-s3 avro base bytestring text
        ];
···
      }:
      mkDerivation {
        pname = "antiope-core";
-       version = "6.1.5";
-       sha256 = "06c8wd4gjlrz1sdk7qpd1l8n29a3jkipy749j3414x7b5fqxbzi7";
+       version = "6.2.0";
+       sha256 = "0g3bhh8vdnkd5h9savhjc053jbb4k7b7chbzcjjqd4kj95v8jmr3";
        libraryHaskellDepends = [
          amazonka amazonka-core base bytestring exceptions generic-lens
          http-client http-types lens monad-logger mtl resourcet text
···
      }:
      mkDerivation {
        pname = "antiope-dynamodb";
-       version = "6.1.5";
-       sha256 = "181ygxvf29acianvnryv1kbn5g69axkagqa54429ja8jfxiblrqq";
+       version = "6.2.0";
+       sha256 = "1kv6ihb6829fbgzz489sg0zyz02rp9p8wk90w4x3sjsynf8djrjj";
        libraryHaskellDepends = [
          amazonka amazonka-core amazonka-dynamodb antiope-core base
          generic-lens lens text unliftio-core unordered-containers
···
      }:
      mkDerivation {
        pname = "antiope-messages";
-       version = "6.1.5";
-       sha256 = "09ysy9r38d216vzq0nm1zfl4fqz8mrqa39c2ivy7pqm4xldsqary";
+       version = "6.2.0";
+       sha256 = "11zkyfv06fsqxznr36hh563yz401y3wg2a5hc6x6ydza4xdnrzdz";
        libraryHaskellDepends = [
          aeson amazonka amazonka-core amazonka-s3 amazonka-sqs antiope-s3
          base generic-lens lens lens-aeson monad-loops network-uri text
···
      }:
      mkDerivation {
        pname = "antiope-s3";
-       version = "6.1.5";
-       sha256 = "0b2mildkgd271c8hwg6b3jf8xgli5bmd4dx9c0ac8ihyn28xr0m8";
+       version = "6.2.0";
+       sha256 = "1gb9ypj5gp6qkzncg44sja35pw2s6qg7msjrlcvhdfbcjs6pxrqj";
        libraryHaskellDepends = [
          amazonka amazonka-core amazonka-s3 antiope-core attoparsec base
          bytestring conduit conduit-extra exceptions generic-lens http-types
···
      }:
      mkDerivation {
        pname = "antiope-sns";
-       version = "6.1.5";
-       sha256 = "07kg0b0iyik0axnycph3irp73cv614qcny3z3rib1rpvbknz9iwh";
+       version = "6.2.0";
+       sha256 = "0npm9q3vf2njiqwyswxc6xh5psjls0skz29mz22y59sk25m5fmkv";
        libraryHaskellDepends = [
          aeson amazonka amazonka-core amazonka-sns base generic-lens lens
          text unliftio-core
···
      }:
      mkDerivation {
        pname = "antiope-sqs";
-       version = "6.1.5";
-       sha256 = "097vxkz54k4ijqqzb8lijr90hvnyyhqm7sqn5qxam3wy355w3z5c";
+       version = "6.2.0";
+       sha256 = "0v33diw8cwvfb9b4k24whbyl4apjq67rh36ndn5qr6627kp3b825";
        libraryHaskellDepends = [
          aeson amazonka amazonka-core amazonka-s3 amazonka-sqs
          antiope-messages antiope-s3 base generic-lens lens lens-aeson
···
      }:
      mkDerivation {
        pname = "apecs";
-       version = "0.7.0";
-       sha256 = "1yah3yn4z6nxm8gdlkmzlbi8h7nd4zb4905dvzb9b66njhff06l2";
+       version = "0.7.1";
+       sha256 = "0cvjqv6zbjzvp01ikfx5lkwb7fbq25555rbvfriwhsfjqanw5pj7";
        libraryHaskellDepends = [
          base containers mtl template-haskell vector
        ];
···
      }:
      mkDerivation {
        pname = "apecs-gloss";
-       version = "0.1.1";
-       sha256 = "0s5vhxgfgj4v51dnrhzfbids0a873113rqb76xr8f5azq6kr9g3p";
+       version = "0.2.0";
+       sha256 = "0qkdjanbrnwhxzr168xwrnhcd1hwsymlb1nvsb1mrklzj93amfvh";
        libraryHaskellDepends = [
          apecs apecs-physics base containers gloss linear
        ];
···
     ({ mkDerivation, base, bytestring }:
      mkDerivation {
        pname = "appar";
-       version = "0.1.5";
-       sha256 = "0qlfwy8nxl1na55p155vq5yn0cqz26mmmh5vs28aqry7kyyxndfi";
-       revision = "1";
-       editedCabalFile = "0adhm7jldcqnikvd8b9wj6p5rnhf4ciwbms0jafwx79w720knj9p";
-       libraryHaskellDepends = [ base bytestring ];
-       description = "A simple applicative parser";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "appar_0_1_7" = callPackage
-    ({ mkDerivation, base, bytestring }:
-     mkDerivation {
-       pname = "appar";
        version = "0.1.7";
        sha256 = "07zjgx7xpjgkjqvga0wv542cyrjzh1mszlczg82nbmij2cflzppn";
        libraryHaskellDepends = [ base bytestring ];
        description = "A simple applicative parser";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "appc" = callPackage
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {inherit (pkgs) arpack;};
 
-  "array_0_5_2_0" = callPackage
+  "array_0_5_3_0" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
        pname = "array";
-       version = "0.5.2.0";
-       sha256 = "12v83s2imxb3p2crnlzrpjh0nk6lpysw9bdk9yahs6f37csa5jaj";
-       revision = "2";
-       editedCabalFile = "1irpwz3spy3yy27kzw8sklhcvxz3mx9fkgqia7r9m069w5wid9kg";
+       version = "0.5.3.0";
+       sha256 = "07pyr2x09n23rdxldqgbx12hlg9dk92q9p56bpcdw3r87ajc3m9z";
        libraryHaskellDepends = [ base ];
        description = "Mutable and immutable arrays";
        license = stdenv.lib.licenses.bsd3;
···
   "aws-lambda-haskell-runtime" = callPackage
     ({ mkDerivation, aeson, base, bytestring, case-insensitive, conduit
      , directory, filepath, hspec, microlens-platform, mtl
-     , optparse-generic, process, QuickCheck, relude, template-haskell
-     , text, wreq
+     , optparse-generic, process, template-haskell, text, uuid, wreq
      }:
      mkDerivation {
        pname = "aws-lambda-haskell-runtime";
-       version = "1.0.4";
-       sha256 = "0cfmdgy0vn62gdi01r02k4yb87s4xv0xhyd06j5ws6ky6cpmmdwx";
+       version = "1.0.7";
+       sha256 = "0dkagfvnxr1bbl6ngglqvvwl4gc66ipvyww4j80nwaxdfwx85wjq";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          aeson base bytestring case-insensitive conduit directory filepath
-         microlens-platform mtl optparse-generic process relude
-         template-haskell text wreq
+         microlens-platform mtl optparse-generic process template-haskell
+         text uuid wreq
        ];
-       executableHaskellDepends = [
-         aeson base bytestring case-insensitive conduit directory filepath
-         microlens-platform mtl optparse-generic process relude
-         template-haskell text wreq
-       ];
-       testHaskellDepends = [
-         aeson base bytestring case-insensitive conduit directory filepath
-         hspec microlens-platform mtl optparse-generic process QuickCheck
-         relude template-haskell text wreq
-       ];
+       executableHaskellDepends = [ base mtl ];
+       testHaskellDepends = [ base hspec mtl ];
        description = "Haskell runtime for AWS Lambda";
        license = stdenv.lib.licenses.asl20;
      }) {};
···
      }) {};
 
   "axel" = callPackage
-    ({ mkDerivation, base, bytestring, directory, filepath
-     , freer-simple, haskell-src-exts, hedgehog, lens, lens-aeson
+    ({ mkDerivation, base, bytestring, containers, directory, filepath
+     , freer-simple, ghcid, haskell-src-exts, hedgehog, lens, lens-aeson
      , optparse-applicative, parsec, process, regex-pcre, singletons
      , split, strict, tasty, tasty-discover, tasty-golden
      , tasty-hedgehog, tasty-hspec, template-haskell, text, transformers
···
      }:
      mkDerivation {
        pname = "axel";
-       version = "0.0.8";
-       sha256 = "16fkrc87yirzha3fgdcbidi7k9xkmb5y5w1i4i10rlikhszfr2b9";
+       version = "0.0.9";
+       sha256 = "0kr7iblj23dlfjzym2ndrns2x7z65sdn2pz8dwxsqvn8jhh24p7f";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
-         base bytestring directory filepath freer-simple haskell-src-exts
-         lens lens-aeson optparse-applicative parsec process regex-pcre
-         singletons strict template-haskell text typed-process vector yaml
+         base bytestring containers directory filepath freer-simple ghcid
+         haskell-src-exts lens lens-aeson optparse-applicative parsec
+         process regex-pcre singletons strict template-haskell text
+         typed-process vector yaml
        ];
        executableHaskellDepends = [
-         base freer-simple optparse-applicative
+         base containers freer-simple optparse-applicative
        ];
        testHaskellDepends = [
-         base bytestring filepath freer-simple hedgehog lens split tasty
-         tasty-discover tasty-golden tasty-hedgehog tasty-hspec transformers
+         base bytestring containers filepath freer-simple hedgehog lens
+         split tasty tasty-discover tasty-golden tasty-hedgehog tasty-hspec
+         transformers
        ];
        testToolDepends = [ tasty-discover ];
        description = "The Axel programming language";
···
      }:
      mkDerivation {
        pname = "barbies";
-       version = "1.0.0.0";
-       sha256 = "05bbn1aqa6r9392fffgjgdl4m8nnagjx27aps5xrcf5x45kk88ci";
+       version = "1.1.0.0";
+       sha256 = "02lnq2f5n75r214lrhkhdl3a85lzn3am197df4a0mp6pvw07z1cs";
        libraryHaskellDepends = [ base bifunctors ];
        testHaskellDepends = [
          base QuickCheck tasty tasty-hunit tasty-quickcheck
···
     ({ mkDerivation, base, monetdb-mapi }:
      mkDerivation {
        pname = "bindings-monetdb-mapi";
-       version = "0.1.0.1";
-       sha256 = "0ghl73n679y5srg4b2jwy6xgnd4lbv7wad8k133k6c7k70zq89hl";
+       version = "0.1.0.2";
+       sha256 = "1f6n2x8c0r72d011piyf8fqclfxcqda98ha3w29c86y66qid0wjm";
        libraryHaskellDepends = [ base ];
        libraryPkgconfigDepends = [ monetdb-mapi ];
        description = "Low-level bindings for the MonetDB API (mapi)";
···
        pname = "biocore";
        version = "0.3.1";
        sha256 = "06ml9p144bv0c9hv6pkcvhdgc0vw0jxzbqb834ilr38kjmrpsar1";
+       revision = "1";
+       editedCabalFile = "0lz3inilvxn1simbpm8002iv7h9wk1gzng2vj3gpxps99zvihqc4";
        libraryHaskellDepends = [ base bytestring stringable ];
        description = "A bioinformatics library";
        license = "LGPL";
···
     ({ mkDerivation, base, blas, netlib-ffi }:
      mkDerivation {
        pname = "blas-ffi";
-       version = "0.0.1.1";
-       sha256 = "0dphqcnnka0ahfgdnshm8r3bd6r5wbpln9kksa6y09yi2nnqh3gf";
+       version = "0.0.2";
+       sha256 = "047qal272s1hc3pp7xy8vyq4dm80nvqin34zvl7wz09c0qrnnvyc";
+       isLibrary = true;
+       isExecutable = true;
        libraryHaskellDepends = [ base netlib-ffi ];
        libraryPkgconfigDepends = [ blas ];
        description = "Auto-generated interface to Fortran BLAS";
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {inherit (pkgs) blas;};
 
-  "blas-ffi_0_0_2" = callPackage
+  "blas-ffi_0_1" = callPackage
     ({ mkDerivation, base, blas, netlib-ffi }:
      mkDerivation {
        pname = "blas-ffi";
-       version = "0.0.2";
-       sha256 = "047qal272s1hc3pp7xy8vyq4dm80nvqin34zvl7wz09c0qrnnvyc";
+       version = "0.1";
+       sha256 = "1zmw1x37ayssplj8w01ivfyh2jjg906c389cjah4hpn5dpb7p9w5";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base netlib-ffi ];
···
        license = stdenv.lib.licenses.asl20;
      }) {};
 
+  "bson_0_3_2_7" = callPackage
+    ({ mkDerivation, base, binary, bytestring, cryptohash
+     , data-binary-ieee754, mtl, network, QuickCheck, test-framework
+     , test-framework-quickcheck2, text, time
+     }:
+     mkDerivation {
+       pname = "bson";
+       version = "0.3.2.7";
+       sha256 = "0avzr3aa3mbr9hcjwd0nr0pnpiym7s35qw7nghz51mrzb76rsci7";
+       libraryHaskellDepends = [
+         base binary bytestring cryptohash data-binary-ieee754 mtl network
+         text time
+       ];
+       testHaskellDepends = [
+         base binary bytestring cryptohash data-binary-ieee754 mtl network
+         QuickCheck test-framework test-framework-quickcheck2 text time
+       ];
+       description = "BSON documents are JSON-like objects with a standard binary encoding";
+       license = stdenv.lib.licenses.asl20;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "bson-generic" = callPackage
     ({ mkDerivation, base, bson, ghc-prim, text }:
      mkDerivation {
···
        pname = "cabal-file-th";
        version = "0.2.4";
        sha256 = "076rprsnb9nyhm97ky4vzfcvirl8wx4g3f68lx7k5inhmkzxfm8b";
+       revision = "1";
+       editedCabalFile = "0qbhrpn23vrqyh71vkbbs5yxwlb8m6nzfpwn6mqz2xi0wwzvl9s6";
        libraryHaskellDepends = [
          base Cabal directory pretty template-haskell
        ];
···
      }:
      mkDerivation {
        pname = "cabal-plan";
-       version = "0.4.0.0";
-       sha256 = "0cbk0xhv189jv656x6a2s0bcnhkks4rlpkhvxbb215v5ldmrkpb1";
-       revision = "1";
-       editedCabalFile = "161vgfbwm8psqa6ncs12j7sn5lqjag1xi62vllvp8xbz9lcvbchb";
+       version = "0.5.0.0";
+       sha256 = "1vfa4lwfjhv4nyl1rwm7i99zdkwriighlhfcz0rgjwzgg56wrihq";
        configureFlags = [ "-fexe" ];
        isLibrary = true;
        isExecutable = true;
···
        ];
        doHaddock = false;
        description = "Library and utiltity for processing cabal's plan.json file";
-       license = stdenv.lib.licenses.gpl3;
+       license = "GPL-2.0-or-later AND BSD-3-Clause";
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
···
      }:
      mkDerivation {
        pname = "casadi-bindings";
-       version = "3.1.0.3";
-       sha256 = "0fb4pyz1f66r811ihpcrq5qpznnxrnrrsh8wfy5g8i5k8srf78n9";
+       version = "3.4.5.0";
+       sha256 = "0ps01gm27dajr8ixfppc2mfmx8yzr24fbq9k5n3c9xgxvn9w7rmc";
        libraryHaskellDepends = [
          base binary casadi-bindings-core casadi-bindings-internal cereal
          containers linear spatial-math vector vector-binary-instances
···
      }:
      mkDerivation {
        pname = "casadi-bindings-core";
-       version = "3.1.0.0";
-       sha256 = "08z6jh8hn23162d6baznvs3br3fin4rp6j4sdfsiid1c3z92q3rn";
+       version = "3.4.5.0";
+       sha256 = "0iqzr6gm30a0v7523yqkipgph89wlyihwmnzidpvki0vlv6fldrl";
        libraryHaskellDepends = [
          base casadi-bindings-internal containers vector
        ];
···
     ({ mkDerivation, base, casadi, containers, vector }:
      mkDerivation {
        pname = "casadi-bindings-internal";
-       version = "0.1.5.0";
-       sha256 = "0p7kbg015447sasn6n4l5kdafrxc2yhgqrxg46xadma6vvv00hf2";
+       version = "0.1.6.1";
+       sha256 = "1y2h0r0l0b9y43n0irsc5s82x7xmzdjdjaz6cqmxk19v0hg4jdnx";
        libraryHaskellDepends = [ base containers vector ];
        librarySystemDepends = [ casadi ];
        description = "low level bindings to CasADi";
···
        pname = "cayley-client";
        version = "0.4.7";
        sha256 = "13jrmlci29hdx0mxs4lzd9xdrdn9qga4891p49nhfpfiz4gch6xs";
+       libraryHaskellDepends = [
+         aeson attoparsec base binary bytestring exceptions http-client
+         http-conduit lens lens-aeson mtl text transformers
+         unordered-containers vector
+       ];
+       testHaskellDepends = [ aeson base hspec unordered-containers ];
+       description = "A Haskell client for the Cayley graph database";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
+  "cayley-client_0_4_8" = callPackage
+    ({ mkDerivation, aeson, attoparsec, base, binary, bytestring
+     , exceptions, hspec, http-client, http-conduit, lens, lens-aeson
+     , mtl, text, transformers, unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "cayley-client";
+       version = "0.4.8";
+       sha256 = "09hrq1k8s8w7rawyn78hjagirs3yrkp79nn7p5w1l8amp27k5cdi";
        libraryHaskellDepends = [
          aeson attoparsec base binary bytestring exceptions http-client
          http-conduit lens lens-aeson mtl text transformers
···
      }:
      mkDerivation {
        pname = "cloudi";
-       version = "1.7.4";
-       sha256 = "0vpsb7sngc8q7bkdg737bfzqfkl14mwjzaycfs0x0fwl6f8l5a8a";
+       version = "1.7.5";
+       sha256 = "08cklswxmd7x0zxkkrlwh1qy57jbqp0dv3x57xskxpmwyhws2vgs";
        libraryHaskellDepends = [
          array base binary bytestring containers network time unix zlib
        ];
···
 
   "codex" = callPackage
     ({ mkDerivation, ascii-progress, base, bytestring, Cabal
-     , containers, cryptohash, directory, either, filepath, hackage-db
-     , http-client, lens, machines, machines-directory, MissingH
-     , monad-loops, network, process, tar, text, transformers, wreq
-     , yaml, zlib
+     , containers, cryptohash, directory, filepath, hackage-db
+     , http-client, lens, machines, machines-directory, network, process
+     , tar, text, transformers, wreq, yaml, zlib
      }:
      mkDerivation {
        pname = "codex";
-       version = "0.5.1.2";
-       sha256 = "0w9m737v3fdgslqdfw16bq7hhsimjazdxrd4r5kzpm0jai39707r";
+       version = "0.5.2.0";
+       sha256 = "1bvz8pzh9qgb7ffnmihcain877igf1hm8rs4z9qx1gckz2c566vv";
+       revision = "1";
+       editedCabalFile = "0v0jlarip2689jxixymqzy36qywla76j78iqzyyc6s7hrd63mrlx";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          ascii-progress base bytestring Cabal containers cryptohash
-         directory either filepath hackage-db http-client lens machines
+         directory filepath hackage-db http-client lens machines
          machines-directory process tar text transformers wreq yaml zlib
        ];
        executableHaskellDepends = [
-         ascii-progress base bytestring Cabal directory either filepath
-         hackage-db MissingH monad-loops network process transformers wreq
-         yaml
+         ascii-progress base Cabal directory filepath hackage-db network
+         process transformers wreq yaml
        ];
        description = "A ctags file generator for cabal project dependencies";
        license = stdenv.lib.licenses.asl20;
···
     ({ mkDerivation, base, containers, convert, lens, text, vector }:
      mkDerivation {
        pname = "container";
-       version = "1.1.5";
-       sha256 = "1hh3ahw1vfmws1hyyl6blqyxaz4qcip0h0d80ia8pb6b1gfbvxsm";
+       version = "1.1.6";
+       sha256 = "0q4zgd7hsnpq5wnn5gk5rz9nq1kfp8ci5kc6yp1rmzbyky3j0211";
        libraryHaskellDepends = [
          base containers convert lens text vector
        ];
···
      }:
      mkDerivation {
        pname = "convert";
-       version = "1.5";
-       sha256 = "0hw2qmb3g9p7zqqk92hwnzamld6kg121dkv4va4hkpcjlhb8af6g";
+       version = "1.5.1";
+       sha256 = "044syln587z5mc4fia0d81p47rpkbvzkyyrcxyckqkh2yj3b2k85";
        libraryHaskellDepends = [
          ansi-wl-pprint base bytestring containers data-default impossible
          lens template-haskell text utf8-string
···
        pname = "cryptoids";
        version = "0.5.1.0";
        sha256 = "0ai7hg4r944hck9vq2ffwwjsxp3mjfvxwhfr8b8765n1bh86i466";
-       revision = "1";
-       editedCabalFile = "0whcgkgdq7hp1z4dr8291q8kpqipfr4mvn8dqq7byxm10v59kn0k";
+       revision = "3";
+       editedCabalFile = "0pjdc90i3qyzxc289kjvn90hnn5xjjzjpgnb24iwqj6ik9asi86g";
        libraryHaskellDepends = [
          base binary bytestring cryptoids-class cryptoids-types cryptonite
          directory exceptions filepath memory
···
        pname = "cryptoids-class";
        version = "0.0.0";
        sha256 = "0zp0d815r0dv2xqdi6drq846zz2a82gpqp6nvap3b5dnx2q3hbjy";
-       revision = "3";
-       editedCabalFile = "1hcdhmksd81sylfjyx0wb4yhrswdwbjlaarq8fbmwcl7fjm4sxfy";
+       revision = "4";
+       editedCabalFile = "0c3cq648sh5cpj0isknhayamzgzv8avixxfpzr4riags70jr28ld";
        libraryHaskellDepends = [ base cryptoids-types exceptions ];
        description = "Typeclass-based interface to cryptoids";
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
   "cryptoids-types" = callPackage
-    ({ mkDerivation, base, binary, http-api-data, path-pieces }:
+    ({ mkDerivation, aeson, base, binary, deepseq, hashable
+     , http-api-data, path-pieces
+     }:
      mkDerivation {
        pname = "cryptoids-types";
-       version = "0.0.0";
-       sha256 = "0qp6lx1k2mqay1i4wgkwgaqamp33gijw0wb13rh71i0qwyvnr51b";
-       revision = "3";
-       editedCabalFile = "1v8fgyh03qggn0fr2kg79m3r1v9i85q0dihgmbq5z4s1y700c8vq";
-       libraryHaskellDepends = [ base binary http-api-data path-pieces ];
+       version = "1.0.0";
+       sha256 = "0dhv92hdydhhgwgdihl3wpiyxl10szrgfnb68ygn07xxhmmfc3hf";
+       revision = "1";
+       editedCabalFile = "0fy6fxzaimgi0nrplzdgi0s26cjz2nrv7y5gdnk0z6k3jd1x5qgb";
+       libraryHaskellDepends = [
+         aeson base binary deepseq hashable http-api-data path-pieces
+       ];
        description = "Shared types for encrypting internal object identifiers before exposure";
        license = stdenv.lib.licenses.bsd3;
      }) {};
···
        pname = "diagrams-lib";
        version = "1.4.2.3";
        sha256 = "175yzi5kw4yd8ykdkpf64q85c7j3p89l90m3h6qcsx9ipv6av9r5";
-       revision = "1";
-       editedCabalFile = "0zsigisgn6sjpfy2hm31zddnsyqm2a046nxb5drjqm7r0aa3vjff";
+       revision = "2";
+       editedCabalFile = "0gn1lpsq1v9qpyhpizyknn3sfixg1b64s0dsl1jf25lz4kcrpbs7";
        libraryHaskellDepends = [
          active adjunctions array base bytestring cereal colour containers
          data-default-class diagrams-core diagrams-solve directory
···
        pname = "diagrams-solve";
        version = "0.1.1";
        sha256 = "17agchqkmj14b17sw50kzxq4hm056g5d8yy0wnqn5w8h1d0my7x4";
-       revision = "3";
-       editedCabalFile = "13vfs5k09c16q3dvqzgfca1kd93pgc4ll8mfl3wracanm5mn5rx7";
+       revision = "4";
+       editedCabalFile = "1yjacw17ga4rh6iw70vclk03qm5xjw4y17c7m43gjw8h3cfaq15d";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [
          base deepseq tasty tasty-hunit tasty-quickcheck
···
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base doctest ];
+       executableHaskellDepends = [ base ];
+       testHaskellDepends = [ base doctest ];
+       description = "Generate driver file for doctest's cabal integration";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
+  "doctest-driver-gen_0_3_0_0" = callPackage
+    ({ mkDerivation, base, doctest }:
+     mkDerivation {
+       pname = "doctest-driver-gen";
+       version = "0.3.0.0";
+       sha256 = "13m5f15076grwln29pnpqrq9h45cy46pagpk1qw3vzspp7k4ahk1";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [ base ];
        executableHaskellDepends = [ base ];
        testHaskellDepends = [ base doctest ];
        description = "Generate driver file for doctest's cabal integration";
···
      }:
      mkDerivation {
        pname = "eventsource-store-specs";
-       version = "1.2.0";
-       sha256 = "1fvwwbbn8407rcxl7sww1k944gq95hniq9s9ys3hzr8a9y65598i";
+       version = "1.2.1";
+       sha256 = "1b7nhigf4r26zfbcq0civbsw8mhsz4hpdsdnm94zmkysl5k58f04";
        libraryHaskellDepends = [
          aeson async base eventsource-api mtl streaming tasty tasty-hspec
          text transformers-base uuid
···
      }:
      mkDerivation {
        pname = "eventsource-stub-store";
-       version = "1.1.0";
-       sha256 = "0rfbn3f6dw6m03f47f68if11xkjd98djhballl50zv7fqifcpz7h";
+       version = "1.1.1";
+       sha256 = "1xd3ngjjpimfpglkgad3r9dmd7sf2mq3kdlbqs4d6xz28gd7vh7y";
        libraryHaskellDepends = [
          async base containers eventsource-api mtl stm streaming
          transformers-base
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "extensible_0_4_10_1" = callPackage
+  "extensible_0_5" = callPackage
     ({ mkDerivation, aeson, base, bytestring, cassava, comonad
      , constraints, deepseq, exceptions, ghc-prim, hashable, lens
      , monad-skeleton, mtl, prettyprinter, primitive, profunctors
-     , QuickCheck, resourcet, semigroups, StateVar, tagged
-     , template-haskell, text, th-lift, transformers
-     , unordered-containers, vector
+     , QuickCheck, resourcet, StateVar, tagged, template-haskell, text
+     , th-lift, transformers, unordered-containers, vector
      }:
      mkDerivation {
        pname = "extensible";
-       version = "0.4.10.1";
-       sha256 = "009z0grpjnnmnsc887k6vgfz5w55mniax25dl4ispj1nq74djksb";
+       version = "0.5";
+       sha256 = "1nsidp8rb3fnkybirgql2ij1vwjzsy2da3qp8abjb1g8aj50ih14";
        libraryHaskellDepends = [
          aeson base bytestring cassava comonad constraints deepseq
          exceptions ghc-prim hashable monad-skeleton mtl prettyprinter
-         primitive profunctors QuickCheck resourcet semigroups StateVar
-         tagged template-haskell text th-lift transformers
-         unordered-containers vector
+         primitive profunctors QuickCheck resourcet StateVar tagged
+         template-haskell text th-lift transformers unordered-containers
+         vector
        ];
        testHaskellDepends = [ base lens QuickCheck template-haskell ];
        description = "Extensible, efficient, optics-friendly data types and effects";
···
      }:
      mkDerivation {
        pname = "extensible-effects-concurrent";
-       version = "0.15.0";
-       sha256 = "0hy1z2caqwyxqw1s3xxkbrzi3f86w3vzch783ajq41xqd6z8spdp";
+       version = "0.18.1";
+       sha256 = "14kx3ipwz51g2qvdmz97v4mckglh6hajw6yzbzllqysgljs243cl";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "extra";
-       version = "1.6.13";
-       sha256 = "0jc5g120ff97sayff10kqn66wz8aw2wymgwgh2livzkf7vqm5q50";
-       libraryHaskellDepends = [
-         base clock directory filepath process time unix
-       ];
-       testHaskellDepends = [ base directory filepath QuickCheck unix ];
-       description = "Extra functions I use";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "extra_1_6_14" = callPackage
-    ({ mkDerivation, base, clock, directory, filepath, process
-     , QuickCheck, time, unix
-     }:
-     mkDerivation {
-       pname = "extra";
        version = "1.6.14";
        sha256 = "170jmwx2wnpa6bs92pcijm4ib4hq0vs4582s6v63wrcn1m9l21m6";
        libraryHaskellDepends = [
···
        testHaskellDepends = [ base directory filepath QuickCheck unix ];
        description = "Extra functions I use";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "extract-dependencies" = callPackage
···
        pname = "fake";
        version = "0.1.1.1";
        sha256 = "0f6iqbyyrllry2q48by8qwaq0n9k7b5d00xgw5vvlr9zdvrpllgf";
+       revision = "1";
+       editedCabalFile = "1a1rsa8hpgpyw8m2bq9ns76n4dbr4iymjhxqkiif6b6xvg8zwld5";
        libraryHaskellDepends = [
          base containers generics-sop random text time
        ];
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "fast-logger_2_4_12" = callPackage
+    ({ mkDerivation, array, auto-update, base, bytestring, directory
+     , easy-file, filepath, hspec, text, unix-compat, unix-time
+     }:
+     mkDerivation {
+       pname = "fast-logger";
+       version = "2.4.12";
+       sha256 = "1jl9kiiijjpilj4zka8ffb2sil31qmgysan2hkld6mhddlr6pjdy";
+       libraryHaskellDepends = [
+         array auto-update base bytestring directory easy-file filepath text
+         unix-compat unix-time
+       ];
+       testHaskellDepends = [ base bytestring directory hspec ];
+       description = "A fast logging system";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "fast-math" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
···
     ({ mkDerivation, base }:
      mkDerivation {
        pname = "fedora-dists";
-       version = "1.0.0.1";
-       sha256 = "0x5lccpwcf2cd97vnqlzyi4lgbyhqcs5ks1sr3l33h1zffpb0br8";
+       version = "1.0.0.2";
+       sha256 = "0jc7kv2zflxwfbidc4wm6wad8hpwfxw7w2ri1zghk3970dkl7lnl";
        libraryHaskellDepends = [ base ];
        description = "Library for Fedora distribution versions";
        license = stdenv.lib.licenses.gpl3;
···
        pname = "filepath-crypto";
        version = "0.1.0.0";
        sha256 = "1bj9haa4ignmk6c6gdiqb4rnwy395pwqdyfy4kgg0z16w0l39mw0";
-       revision = "6";
-       editedCabalFile = "0lg22k1f9l51a8bdnhkwq07mg0m3w3rhgavp1lxi3vmsszsmpmvc";
+       revision = "7";
+       editedCabalFile = "0dniq1rzv6qb75svf2ya32r0116pjh9jlgly7106x3gyziq2cwh3";
        libraryHaskellDepends = [
          base binary bytestring case-insensitive cryptoids cryptoids-class
          cryptoids-types exceptions filepath sandi template-haskell
···
        pname = "functor-infix";
        version = "0.0.5";
        sha256 = "0rifm1p5zq2711vak2lyxzz2xs03saym3m3695wpf3zy38safbpn";
+       revision = "1";
+       editedCabalFile = "0nvk9hff0vd3s7q67pb4my5vfz1y954y0l8vlbbmdx9i20r1m8nf";
        libraryHaskellDepends = [ base template-haskell ];
        description = "Infix operators for mapping over compositions of functors. Lots of them.";
        license = stdenv.lib.licenses.mit;
···
     ({ mkDerivation, base, ghc-prim, lens }:
      mkDerivation {
        pname = "functor-utils";
-       version = "1.17.1";
-       sha256 = "1ixssxdhw94l1kjxd5k4gvq8wz4b9d0vww5mg2al9q3vzb7d4pld";
+       version = "1.17.2";
+       sha256 = "1sf4d3af4kf341g7slpylm2113cy0597fngr5ldlds8znylspmms";
        libraryHaskellDepends = [ base ghc-prim lens ];
        description = "Collection of functor utilities, providing handy operators, like generalization of (.).";
        license = stdenv.lib.licenses.asl20;
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "ghc-prof_1_4_1_5" = callPackage
+    ({ mkDerivation, attoparsec, base, containers, directory, filepath
+     , process, scientific, tasty, tasty-hunit, temporary, text, time
+     }:
+     mkDerivation {
+       pname = "ghc-prof";
+       version = "1.4.1.5";
+       sha256 = "0cpyzfyfkq6c17xpccgibjpq8j0l4w33mbpivim3kha7k76ilbg4";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         attoparsec base containers scientific text time
+       ];
+       testHaskellDepends = [
+         attoparsec base containers directory filepath process tasty
+         tasty-hunit temporary text
+       ];
+       description = "Library for parsing GHC time and allocation profiling reports";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "ghc-prof-aeson" = callPackage
     ({ mkDerivation, aeson, base, bytestring, hspec, text, vector }:
      mkDerivation {
···
 
   "ginger" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, base, bytestring
-     , data-default, filepath, http-types, mtl, parsec, process, safe
-     , scientific, tasty, tasty-hunit, tasty-quickcheck, text, time
-     , transformers, unordered-containers, utf8-string, vector, yaml
+     , data-default, filepath, http-types, mtl, parsec, process
+     , regex-tdfa, safe, scientific, tasty, tasty-hunit
+     , tasty-quickcheck, text, time, transformers, unordered-containers
+     , utf8-string, vector, yaml
      }:
      mkDerivation {
        pname = "ginger";
-       version = "0.8.2.0";
-       sha256 = "06k2imp511v4xxlzqgii14hf0ncnc6wci3hm7w48z332c5nk24m1";
+       version = "0.8.4.0";
+       sha256 = "0mk0jmw0qvbv73n7g8n14shnyxjkkq6wp3vnk1gx1dnmbk20vdm7";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          aeson aeson-pretty base bytestring data-default filepath http-types
-         mtl parsec safe scientific text time transformers
+         mtl parsec regex-tdfa safe scientific text time transformers
          unordered-containers utf8-string vector
        ];
        executableHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "google-oauth2-jwt";
-       version = "0.3.0";
-       sha256 = "1mi7mdkq2d7n3pxlspc5zgval7wb2q7sn261k704nwrbm0phzzbj";
-       libraryHaskellDepends = [
-         base base64-bytestring bytestring HsOpenSSL RSA text unix-time
-       ];
-       description = "Get a signed JWT for Google Service Accounts";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "google-oauth2-jwt_0_3_1" = callPackage
-    ({ mkDerivation, base, base64-bytestring, bytestring, HsOpenSSL
-     , RSA, text, unix-time
-     }:
-     mkDerivation {
-       pname = "google-oauth2-jwt";
        version = "0.3.1";
        sha256 = "121g7fsdcnv65gp81z450dqqw6ii75pwn3cbilwx5yv4mm571mvi";
        libraryHaskellDepends = [
···
        ];
        description = "Get a signed JWT for Google Service Accounts";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "google-search" = callPackage
···
      }:
      mkDerivation {
        pname = "google-server-api";
-       version = "0.2.0.1";
-       sha256 = "0d07flz3vpdyq4ifldp466zhj19ll7zlcnwn0ns47d72r79wghiw";
+       version = "0.3.0.0";
+       sha256 = "1zrgflz6pav8ygjjisjm35w7a232116f90s0pd8jqf46an2bm8i2";
        libraryHaskellDepends = [
          aeson aeson-casing base base64-bytestring bytestring HsOpenSSL
          http-api-data http-client http-client-tls mime-mail monad-control
···
      }:
      mkDerivation {
        pname = "graph-wrapper";
-       version = "0.2.5.1";
-       sha256 = "04z1qbsf1c31r0mhn8bgr8hisffxacq3j61y4fym28idr8zqaqc3";
-       libraryHaskellDepends = [ array base containers ];
-       testHaskellDepends = [
-         array base containers deepseq hspec QuickCheck
-       ];
-       description = "A wrapper around the standard Data.Graph with a less awkward interface";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "graph-wrapper_0_2_5_2" = callPackage
-    ({ mkDerivation, array, base, containers, deepseq, hspec
-     , QuickCheck
-     }:
-     mkDerivation {
-       pname = "graph-wrapper";
        version = "0.2.5.2";
        sha256 = "1kcdfr1bz2ks71gapz6wrzv7sj6qbmj1zadj1cmh39g9xvqjx94q";
        libraryHaskellDepends = [ array base containers ];
···
        ];
        description = "A wrapper around the standard Data.Graph with a less awkward interface";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "graphbuilder" = callPackage
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "groundhog_0_10_0" = callPackage
+    ({ mkDerivation, aeson, attoparsec, base, base64-bytestring
+     , blaze-builder, bytestring, containers, monad-control, mtl
+     , resourcet, safe-exceptions, scientific, text, time, transformers
+     , transformers-base, transformers-compat
+     }:
+     mkDerivation {
+       pname = "groundhog";
+       version = "0.10.0";
+       sha256 = "1wckm2qrgmv1ccavwvq8ji3pfb4y197s1n1adv8hz9bqk246byrq";
+       libraryHaskellDepends = [
+         aeson attoparsec base base64-bytestring blaze-builder bytestring
+         containers monad-control mtl resourcet safe-exceptions scientific
+         text time transformers transformers-base transformers-compat
+       ];
+       description = "Type-safe datatype-database mapping library";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "groundhog-converters" = callPackage
     ({ mkDerivation, aeson, base, bimap, bytestring, containers
      , groundhog, groundhog-sqlite, groundhog-th, tasty, tasty-hunit
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "groundhog-inspector_0_10_0" = callPackage
+    ({ mkDerivation, aeson-pretty, base, bytestring, cmdargs
+     , containers, groundhog, groundhog-sqlite, groundhog-th, mtl
+     , regex-compat, syb, template-haskell, text, time, transformers
+     }:
+     mkDerivation {
+       pname = "groundhog-inspector";
+       version = "0.10.0";
+       sha256 = "1l4smiydqqgpfqcyq77d2g0cvglanqfhlhx3y1k9n3kx94yss5a2";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson-pretty base bytestring containers groundhog groundhog-th
+         regex-compat syb template-haskell text time transformers
+       ];
+       executableHaskellDepends = [
+         base bytestring cmdargs containers groundhog groundhog-sqlite
+         groundhog-th mtl
+       ];
+       description = "Type-safe datatype-database mapping library";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "groundhog-mysql" = callPackage
     ({ mkDerivation, base, bytestring, containers, groundhog
      , monad-control, monad-logger, mysql, mysql-simple, resource-pool
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "groundhog-mysql_0_10" = callPackage
+    ({ mkDerivation, base, bytestring, containers, groundhog
+     , monad-control, monad-logger, mysql, mysql-simple, resource-pool
+     , resourcet, text, time, transformers
+     }:
+     mkDerivation {
+       pname = "groundhog-mysql";
+       version = "0.10";
+       sha256 = "1idyisl0dbij4ffd0bn1bm681az87wc30qnkn1vmr0cd0xb6mwnx";
+       libraryHaskellDepends = [
+         base bytestring containers groundhog monad-control monad-logger
+         mysql mysql-simple resource-pool resourcet text time transformers
+       ];
+       description = "MySQL backend for the groundhog library";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "groundhog-postgresql" = callPackage
     ({ mkDerivation, aeson, attoparsec, base, blaze-builder, bytestring
      , containers, groundhog, monad-control, postgresql-libpq
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "groundhog-postgresql_0_10" = callPackage
+    ({ mkDerivation, aeson, attoparsec, base, blaze-builder, bytestring
+     , containers, groundhog, monad-control, postgresql-libpq
+     , postgresql-simple, resource-pool, resourcet, text, time
+     , transformers, vector
+     }:
+     mkDerivation {
+       pname = "groundhog-postgresql";
+       version = "0.10";
+       sha256 = "1digvi8ra58r122i030h0b089sbyzaclir1cg4iqaflbzrnz45l9";
+       libraryHaskellDepends = [
+         aeson attoparsec base blaze-builder bytestring containers groundhog
+         monad-control postgresql-libpq postgresql-simple resource-pool
+         resourcet text time transformers vector
+       ];
+       description = "PostgreSQL backend for the groundhog library";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "groundhog-sqlite" = callPackage
     ({ mkDerivation, base, bytestring, containers, direct-sqlite
      , groundhog, monad-control, resource-pool, resourcet, text
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "groundhog-sqlite_0_10_0" = callPackage
+    ({ mkDerivation, base, bytestring, containers, direct-sqlite
+     , groundhog, monad-control, resource-pool, resourcet, text
+     , transformers, unordered-containers
+     }:
+     mkDerivation {
+       pname = "groundhog-sqlite";
+       version = "0.10.0";
+       sha256 = "1z6yss15aw0a14i0nj0flb0h2641sjr70mhasp718qmc4iwkgw7x";
+       libraryHaskellDepends = [
+         base bytestring containers direct-sqlite groundhog monad-control
+         resource-pool resourcet text transformers unordered-containers
+       ];
+       description = "Sqlite3 backend for the groundhog library";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "groundhog-th" = callPackage
     ({ mkDerivation, aeson, base, bytestring, containers, groundhog
      , template-haskell, text, time, unordered-containers, yaml
···
        pname = "groundhog-th";
        version = "0.9.0.1";
        sha256 = "0hrk86s5mfj33sx5im6pcym1br160vnp17yhi82b2x1imm26cmlk";
+       libraryHaskellDepends = [
+         aeson base bytestring containers groundhog template-haskell text
+         time unordered-containers yaml
+       ];
+       description = "Type-safe datatype-database mapping library";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
+  "groundhog-th_0_10" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, containers, groundhog
+     , template-haskell, text, time, unordered-containers, yaml
+     }:
+     mkDerivation {
+       pname = "groundhog-th";
+       version = "0.10";
+       sha256 = "1bshffmv8x0yqd9d7m3s3abnhnz1g4ny3va5mkzsvy1snzxj7xlb";
        libraryHaskellDepends = [
          aeson base bytestring containers groundhog template-haskell text
          time unordered-containers yaml
···
        license = stdenv.lib.licenses.publicDomain;
      }) {};
 
+  "hakyll-images" = callPackage
+    ({ mkDerivation, base, bytestring, hakyll, HUnit-approx
+     , JuicyPixels, JuicyPixels-extra, tasty, tasty-hunit
+     }:
+     mkDerivation {
+       pname = "hakyll-images";
+       version = "0.1.0";
+       sha256 = "1l135gmlm2ydqj3d27gfarykcg6k1g204cysm3bk163f499b8w50";
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         base bytestring hakyll JuicyPixels JuicyPixels-extra
+       ];
+       testHaskellDepends = [
+         base bytestring hakyll HUnit-approx JuicyPixels JuicyPixels-extra
+         tasty tasty-hunit
+       ];
+       description = "Hakyll utilities to work with images";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "hakyll-ogmarkup" = callPackage
     ({ mkDerivation, base, hakyll, ogmarkup }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "hasbolt";
-       version = "0.1.3.1";
-       sha256 = "0d6prk5fav5l0d4j0ndinn3szimy02dmayx997z5yg6yb5ix3lai";
-       libraryHaskellDepends = [
-         base binary bytestring connection containers data-binary-ieee754
-         data-default network text transformers
-       ];
-       testHaskellDepends = [
-         base bytestring containers hex hspec QuickCheck text
-       ];
-       description = "Haskell driver for Neo4j 3+ (BOLT protocol)";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "hasbolt_0_1_3_2" = callPackage
-    ({ mkDerivation, base, binary, bytestring, connection, containers
-     , data-binary-ieee754, data-default, hex, hspec, network
-     , QuickCheck, text, transformers
-     }:
-     mkDerivation {
-       pname = "hasbolt";
        version = "0.1.3.2";
        sha256 = "14sq3iqbrfkwyswdka2285cdhwx3c6srfhn5qb7yw1nfjx2bdb1i";
        libraryHaskellDepends = [
···
        ];
        description = "Haskell driver for Neo4j 3+ (BOLT protocol)";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "hasbolt-extras" = callPackage
···
      }:
      mkDerivation {
        pname = "haskdogs";
-       version = "0.5.3";
-       sha256 = "1n3vwrm99h4kzcimav18dkbvkpkhspwdf5gz8da1sr4g0m4kg96n";
+       version = "0.5.4";
+       sha256 = "1f35np3a99y3aifqgp24c5wdjr5nvvs3jj6g71v39355sjj1hsqq";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "haskell-dap";
-       version = "0.0.9.0";
-       sha256 = "1flsz93wbhd61yfydbfbb3q8brhh0d0gzfsdd3xscwvcbdzgw9qr";
+       version = "0.0.10.0";
+       sha256 = "1d2jma4gly0bh1a114a7pm6xq13y5py3p1hkkn24755mi4b0ykqa";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base ];
···
      }:
      mkDerivation {
        pname = "haskell-names";
-       version = "0.9.5";
-       sha256 = "0j1snakldb29v8786licz4k2b92pbdbxhxgyz22rvjypdxyhaa7h";
+       version = "0.9.6";
+       sha256 = "06g1h1dvsh31hm18v3hkx2s4bcrv2h49kgc2x9k1xk6532a9503w";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          aeson base bytestring containers data-lens-light filepath
···
      }:
      mkDerivation {
        pname = "haskoin-store";
-       version = "0.9.1";
-       sha256 = "099fng9wy9qhcxn14m1mlpq004bl51xas3rk6jkspqv32d4rr6zs";
+       version = "0.9.2";
+       sha256 = "1p4za0b6n7ldz7jnq25n9f7wmngxy8ic0vy1kppb7wka0a96sdh1";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
     ({ mkDerivation, base, doctest, time }:
      mkDerivation {
        pname = "herf-time";
-       version = "0.2.2";
-       sha256 = "13nn46l5mf555rab3fwl38g4fznjh3n07754l671vqcr8c5zfm4m";
+       version = "0.3.0";
+       sha256 = "00ar1kb29gjvna7rcdg6wj3f22dil2pzbzy8zblvyc452zjy03y2";
        libraryHaskellDepends = [ base time ];
        testHaskellDepends = [ base doctest ];
        description = "haskell time manipulation in a 'kerf like' style";
···
      }:
      mkDerivation {
        pname = "hinterface";
-       version = "0.8.0";
-       sha256 = "1mzq87sdcx50i67kf2lv5wg0k6ahxf1x2qxvi41dnaxkjjl1vcmr";
+       version = "0.8.1";
+       sha256 = "1qpdapvxy03jqrvn4p45pi2zhiy888k8acysb0fqzi3f8mypqm1c";
        libraryHaskellDepends = [
          array async base binary bytestring containers cryptonite deepseq
          exceptions lifted-async lifted-base memory monad-control
···
      }:
      mkDerivation {
        pname = "hosc";
-       version = "0.16";
-       sha256 = "1xj5kkpkzzwfi26n28s0gkr9vzkmvp276n9jb75j2ccbr8q79vbj";
-       revision = "1";
-       editedCabalFile = "0n9ra6qhy5wighwa3zn5496473kdarhdgzsvmhnlp14s6sgw8akb";
+       version = "0.17";
+       sha256 = "0340lldzim02ixj4n0smfwn20y5i0z7v0gqgbb0mdjs6c90rqhv6";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          base binary blaze-builder bytestring data-binary-ieee754 network
          time transformers
        ];
        description = "Haskell Open Sound Control";
-       license = "GPL";
+       license = stdenv.lib.licenses.gpl3;
      }) {};
 
   "hosc-json" = callPackage
···
 
   "hsc3" = callPackage
     ({ mkDerivation, array, base, binary, bytestring, containers
-     , data-default, data-ordlist, directory, filepath, hashable, hosc
-     , network, process, random, safe, split, transformers, vector
+     , data-ordlist, directory, filepath, hosc, murmur-hash, network
+     , process, random, safe, split, transformers, vector
      }:
      mkDerivation {
        pname = "hsc3";
-       version = "0.16";
-       sha256 = "0m6pas8dx48mx91159s7p7fljnivs13cg34gys906nhq11dmjdqn";
+       version = "0.17";
+       sha256 = "1k7gm0qk96rm7rphmmwlqh99kn5v79g8szyyhb9cqg3rfv6as1ld";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
-         array base binary bytestring containers data-default data-ordlist
-         directory filepath hashable hosc network process random safe split
+         array base binary bytestring containers data-ordlist directory
+         filepath hosc murmur-hash network process random safe split
          transformers vector
        ];
        description = "Haskell SuperCollider";
-       license = "GPL";
+       license = stdenv.lib.licenses.gpl3;
      }) {};
 
   "hsc3-auditor" = callPackage
···
      }:
      mkDerivation {
        pname = "htvm";
-       version = "0.1.0.0";
-       sha256 = "0bf3dqyqrdi9mw72kp6hid4p6jk3gs5vw5fd1ycjgid218na7qmm";
+       version = "0.1.2";
+       sha256 = "0ggb6g6cdx6qzvda4l2z9danq5pkwncf3p2cyb68bwghs988fgxs";
        libraryHaskellDepends = [
          array base bytestring containers deriving-compat directory Earley
          filepath mtl pretty-show process recursion-schemes temporary text
···
          tasty tasty-hunit tasty-quickcheck temporary text
        ];
        testSystemDepends = [ tvm_runtime ];
-       description = "TVM bindings";
+       description = "Bindings for TVM machine learning framework";
        license = stdenv.lib.licenses.gpl3;
      }) {tvm_runtime = null;};
 
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "hw-ip_1_0_0_0" = callPackage
-    ({ mkDerivation, appar, attoparsec, base, generic-lens, hedgehog
+  "hw-ip_2_0_0_0" = callPackage
+    ({ mkDerivation, appar, base, containers, generic-lens, hedgehog
      , hspec, hw-bits, hw-hspec-hedgehog, iproute, text
      }:
      mkDerivation {
        pname = "hw-ip";
-       version = "1.0.0.0";
-       sha256 = "0di0r4dq1fzmb1cgmks54wqamx9jsjgnv4qjs3s8kwszz19plpfw";
+       version = "2.0.0.0";
+       sha256 = "04hb06rbkipm21fji9n5v56wm2jvdnr7w42ndp9x2hyp3m1i9sm0";
        libraryHaskellDepends = [
-         appar attoparsec base generic-lens hw-bits iproute text
+         appar base containers generic-lens hw-bits iproute text
        ];
        testHaskellDepends = [
-         attoparsec base generic-lens hedgehog hspec hw-bits
-         hw-hspec-hedgehog text
+         appar base generic-lens hedgehog hspec hw-bits hw-hspec-hedgehog
+         text
        ];
        description = "Library for manipulating IP addresses and CIDR blocks";
        license = stdenv.lib.licenses.bsd3;
···
     ({ mkDerivation, base, process }:
      mkDerivation {
        pname = "ihs";
-       version = "0.1.0.2";
-       sha256 = "0cprv8g7kz07s5954020ac9yfggf3d2wmwp4xa61q4sz5rs7wiwq";
-       isLibrary = false;
-       isExecutable = true;
-       executableHaskellDepends = [ base process ];
-       description = "Interpolated Haskell";
-       license = stdenv.lib.licenses.publicDomain;
-     }) {};
-
-  "ihs_0_1_0_3" = callPackage
-    ({ mkDerivation, base, process }:
-     mkDerivation {
-       pname = "ihs";
        version = "0.1.0.3";
        sha256 = "1zfmxgb3l7mihzjyggzb30d9b57y2z80yk562z2x2padsqx95gqk";
        isLibrary = false;
···
        executableHaskellDepends = [ base process ];
        description = "Interpolated Haskell";
        license = stdenv.lib.licenses.publicDomain;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "ihttp" = callPackage
···
     ({ mkDerivation, base, lens }:
      mkDerivation {
        pname = "impossible";
-       version = "1.1.3";
-       sha256 = "01p9s6nzzlmgg1gr42ys6wkxnzp1jqs3ay8jz5lbm1nkbjlabs4n";
+       version = "1.1.4";
+       sha256 = "0557f8a9aaslkhpyp7b6zidg88a3472ya31rp8amqf71393nvkqp";
        libraryHaskellDepends = [ base lens ];
        description = "Set of data and type definitions of impossible types. Impossible types are useful when declaring type classes / type families instances that should not be expanded by GHC until a specific type is provided in order to keep the types nice and readable.";
        license = stdenv.lib.licenses.asl20;
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "inline-c_0_7_0_1" = callPackage
+    ({ mkDerivation, ansi-wl-pprint, base, bytestring, containers
+     , hashable, hspec, mtl, parsec, parsers, QuickCheck, raw-strings-qq
+     , regex-posix, template-haskell, transformers, unordered-containers
+     , vector
+     }:
+     mkDerivation {
+       pname = "inline-c";
+       version = "0.7.0.1";
+       sha256 = "19scbviwiv1fbsdcjji3dscjg7w0xa8r97xwkqqrwm7zhvrg5wns";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         ansi-wl-pprint base bytestring containers hashable mtl parsec
+         parsers template-haskell transformers unordered-containers vector
+       ];
+       testHaskellDepends = [
+         ansi-wl-pprint base containers hashable hspec parsers QuickCheck
+         raw-strings-qq regex-posix template-haskell transformers
+         unordered-containers vector
+       ];
+       description = "Write Haskell source files including C code inline. No FFI required.";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "inline-c-cpp_0_1_0_0" = callPackage
     ({ mkDerivation, base, inline-c, template-haskell }:
      mkDerivation {
···
        pname = "inline-r";
        version = "0.9.2";
        sha256 = "1h2gwrh8kzx3przx29gcl4wffni3bxy1yrfabf88bdxjwj79s7z0";
+       revision = "1";
+       editedCabalFile = "01cxsjdxy5brdnw966928bcdivc8ab7kq91vdqkg2q801jf5jj9g";
        libraryHaskellDepends = [
          aeson base bytestring containers data-default-class deepseq
          exceptions inline-c mtl pretty primitive process reflection setenv
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "interpolator" = callPackage
+    ({ mkDerivation, aeson, base, containers, either, hspec
+     , mono-traversable, mtl, product-profunctors, profunctors
+     , QuickCheck, template-haskell, text
+     }:
+     mkDerivation {
+       pname = "interpolator";
+       version = "0.1";
+       sha256 = "049zx47z071n8k83xc7fwqqd397pg0g7misrggj4w27gxvdlvr7r";
+       libraryHaskellDepends = [
+         aeson base containers either mono-traversable mtl
+         product-profunctors profunctors QuickCheck template-haskell text
+       ];
+       testHaskellDepends = [
+         aeson base containers either hspec mono-traversable mtl
+         product-profunctors profunctors QuickCheck template-haskell text
+       ];
+       description = "Runtime interpolation of environment variables in records using profunctors";
+       license = stdenv.lib.licenses.mit;
+     }) {};
+
   "interprocess" = callPackage
     ({ mkDerivation, base, typed-process }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "io-choice";
-       version = "0.0.6";
-       sha256 = "1vqw5v1b9mrkhhszxp1rg8gl1d53akdlzwh40w01b1ni208jhav1";
-       libraryHaskellDepends = [
-         base lifted-base monad-control template-haskell transformers
-         transformers-base
-       ];
-       testHaskellDepends = [
-         base hspec lifted-base monad-control transformers
-       ];
-       description = "Choice for IO and lifted IO";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "io-choice_0_0_7" = callPackage
-    ({ mkDerivation, base, hspec, lifted-base, monad-control
-     , template-haskell, transformers, transformers-base
-     }:
-     mkDerivation {
-       pname = "io-choice";
        version = "0.0.7";
        sha256 = "16v6b9r5k2y5vm2s8k3j7xc5wh77nqd8j636mc6wxcxwn3260jir";
        libraryHaskellDepends = [
···
        ];
        description = "Choice for IO and lifted IO";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "io-machine" = callPackage
···
      }:
      mkDerivation {
        pname = "iproute";
-       version = "1.7.6";
-       sha256 = "1svczhzy126w7pa5vyfg90xrvi2ym34f47nj4hhcpx13dv06g5wi";
-       libraryHaskellDepends = [
-         appar base byteorder containers network
-       ];
-       testHaskellDepends = [
-         appar base byteorder containers doctest hspec network QuickCheck
-         safe
-       ];
-       description = "IP Routing Table";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "iproute_1_7_7" = callPackage
-    ({ mkDerivation, appar, base, byteorder, containers, doctest, hspec
-     , network, QuickCheck, safe
-     }:
-     mkDerivation {
-       pname = "iproute";
        version = "1.7.7";
        sha256 = "0gab5930nvzrpvisx3x43ydnp2rd4fbmy9cq1zpgqy1adx5gx8z6";
        libraryHaskellDepends = [
···
        ];
        description = "IP Routing Table";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "iptables-helpers" = callPackage
···
        license = stdenv.lib.licenses.asl20;
      }) {};
 
+  "jose_0_8_0_0" = callPackage
+    ({ mkDerivation, aeson, attoparsec, base, base64-bytestring
+       sha256 = "0693ca7rwai4s8i8vqbmmq3q50pd23svcnnnd1cxjbqxh6hgsbs1";
+       sha256 = "0693ca7rwai4s8i8vqbmmq3q50pd23svcnnnd1cxjbqxh6hgsbs1";
+       sha256 = "0693ca7rwai4s8i8vqbmmq3q50pd23svcnnnd1cxjbqxh6hgsbs1";
+     , template-haskell, text, time, unix, unordered-containers, vector
+     , x509
+     }:
+     mkDerivation {
+       sha256 = "0693ca7rwai4s8i8vqbmmq3q50pd23svcnnnd1cxjbqxh6hgsbs1";
+       version = "0.8.0.0";
+       sha256 = "027698xq5l8in420x3sc5zqwp16i1jzjcy8rlh546j8acxcvrqc4";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+       sha256 = "0693ca7rwai4s8i8vqbmmq3q50pd23svcnnnd1cxjbqxh6hgsbs1";
+       sha256 = "0693ca7rwai4s8i8vqbmmq3q50pd23svcnnnd1cxjbqxh6hgsbs1";
+       sha256 = "0693ca7rwai4s8i8vqbmmq3q50pd23svcnnnd1cxjbqxh6hgsbs1";
+       sha256 = "0693ca7rwai4s8i8vqbmmq3q50pd23svcnnnd1cxjbqxh6hgsbs1";
+       ];
+       executableHaskellDepends = [
+         aeson base bytestring lens mtl semigroups text unix
+       ];
+       testHaskellDepends = [
+       sha256 = "0693ca7rwai4s8i8vqbmmq3q50pd23svcnnnd1cxjbqxh6hgsbs1";
+       sha256 = "0693ca7rwai4s8i8vqbmmq3q50pd23svcnnnd1cxjbqxh6hgsbs1";
+       sha256 = "0693ca7rwai4s8i8vqbmmq3q50pd23svcnnnd1cxjbqxh6hgsbs1";
+         tasty-quickcheck template-haskell text time unordered-containers
+       sha256 = "0693ca7rwai4s8i8vqbmmq3q50pd23svcnnnd1cxjbqxh6hgsbs1";
+       ];
+       sha256 = "0693ca7rwai4s8i8vqbmmq3q50pd23svcnnnd1cxjbqxh6hgsbs1";
+       license = stdenv.lib.licenses.asl20;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
        sha256 = "0693ca7rwai4s8i8vqbmmq3q50pd23svcnnnd1cxjbqxh6hgsbs1";
     ({ mkDerivation, aeson, attoparsec, base, bytestring, cereal
        sha256 = "0693ca7rwai4s8i8vqbmmq3q50pd23svcnnnd1cxjbqxh6hgsbs1";
···
        ];
        sha256 = "0693ca7rwai4s8i8vqbmmq3q50pd23svcnnnd1cxjbqxh6hgsbs1";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "json_0_9_3" = callPackage
+       sha256 = "0693ca7rwai4s8i8vqbmmq3q50pd23svcnnnd1cxjbqxh6hgsbs1";
+       sha256 = "0693ca7rwai4s8i8vqbmmq3q50pd23svcnnnd1cxjbqxh6hgsbs1";
+     }:
+     mkDerivation {
+       sha256 = "0693ca7rwai4s8i8vqbmmq3q50pd23svcnnnd1cxjbqxh6hgsbs1";
+       version = "0.9.3";
+       sha256 = "1z8s3mfg76p2flqqd2wqsi96l5bg8k8w8m58zlv81pw3k7h1vbwb";
+       libraryHaskellDepends = [
+       sha256 = "0693ca7rwai4s8i8vqbmmq3q50pd23svcnnnd1cxjbqxh6hgsbs1";
+       ];
+       sha256 = "0693ca7rwai4s8i8vqbmmq3q50pd23svcnnnd1cxjbqxh6hgsbs1";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
        sha256 = "0693ca7rwai4s8i8vqbmmq3q50pd23svcnnnd1cxjbqxh6hgsbs1";
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {Judy = null;};
 
+  "juicy-draw" = callPackage
+    ({ mkDerivation, base, JuicyPixels, numeric-extras, primitive }:
+     mkDerivation {
+       pname = "juicy-draw";
+       version = "0.2.0.0";
+       sha256 = "0fi4kwcb8mqnzi3cx2gzpls6nyc8vxnhjfgrb7zf04bpcsph7rgr";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base JuicyPixels numeric-extras primitive
+       ];
+       executableHaskellDepends = [ base JuicyPixels ];
+       description = "Draw and fill lines, rectangles and polygons";
+       license = stdenv.lib.licenses.mit;
+     }) {};
+
        sha256 = "0693ca7rwai4s8i8vqbmmq3q50pd23svcnnnd1cxjbqxh6hgsbs1";
        sha256 = "0693ca7rwai4s8i8vqbmmq3q50pd23svcnnnd1cxjbqxh6hgsbs1";
        sha256 = "0693ca7rwai4s8i8vqbmmq3q50pd23svcnnnd1cxjbqxh6hgsbs1";
···
      }:
      mkDerivation {
        sha256 = "0693ca7rwai4s8i8vqbmmq3q50pd23svcnnnd1cxjbqxh6hgsbs1";
-       version = "0.8.1.0";
-       sha256 = "0693ca7rwai4s8i8vqbmmq3q50pd23svcnnnd1cxjbqxh6hgsbs1";
+       version = "0.8.1.1";
+       sha256 = "013cvfp8cfj90lj4n41g8wwrv6xj3iql4m3zzawmpxzkqwmflsqy";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "lambdabot-xmpp" = callPackage
+    ({ mkDerivation, base, data-default, lambdabot-core
+     , lambdabot-haskell-plugins, lambdabot-irc-plugins
+     , lambdabot-misc-plugins, lambdabot-novelty-plugins
+     , lambdabot-reference-plugins, lambdabot-social-plugins
+     , lifted-base, mtl, network, pontarius-xmpp, split, text, tls
+     , x509-validation, xml-types
+     }:
+     mkDerivation {
+       pname = "lambdabot-xmpp";
+       version = "0.1.0.0";
+       sha256 = "1bn8gd2gxl44xqffiy8skh714hkvfv2d318v1qg9k52pp53al2ny";
+       isLibrary = false;
+       isExecutable = true;
+       executableHaskellDepends = [
+         base data-default lambdabot-core lambdabot-haskell-plugins
+         lambdabot-irc-plugins lambdabot-misc-plugins
+         lambdabot-novelty-plugins lambdabot-reference-plugins
+         lambdabot-social-plugins lifted-base mtl network pontarius-xmpp
+         split text tls x509-validation xml-types
+       ];
+       description = "Lambdabot plugin for XMPP (Jabber) protocol";
+       license = "unknown";
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
        sha256 = "0693ca7rwai4s8i8vqbmmq3q50pd23svcnnnd1cxjbqxh6hgsbs1";
        sha256 = "0693ca7rwai4s8i8vqbmmq3q50pd23svcnnnd1cxjbqxh6hgsbs1";
        sha256 = "0693ca7rwai4s8i8vqbmmq3q50pd23svcnnnd1cxjbqxh6hgsbs1";
···
      }:
      mkDerivation {
        pname = "layered-state";
-       version = "1.1.4";
-       sha256 = "06mwkz6816nkwlsc51hfx0y67dhf42rkib165xag7kga7843idxa";
+       version = "1.1.5";
+       sha256 = "122z7jzhy65ksdkgn505gkjgn0j04gqq38q5k1d3xlg96x670chk";
        libraryHaskellDepends = [
          base constraints data-default exceptions lens lens-utils
          monad-branch monoid mtl primitive profunctors prologue transformers
···
      }:
      mkDerivation {
        pname = "layouting";
-       version = "1.1.3";
-       sha256 = "1ji0hmfa87n3pl61gmgk4phmpir29j5r81ack95s3h7nxh0q5qh7";
+       version = "1.1.4";
+       sha256 = "0p50zg1xydvci313dh87g0asx292vbhbz5iaywcw9rapwxlg5zld";
        libraryHaskellDepends = [
          base container layered-state prologue terminal-text text
        ];
···
      }:
      mkDerivation {
        pname = "lens-utils";
-       version = "1.4.5";
-       sha256 = "00xcwyl12w95k14rc12ww2i0kgbrv39q1lvq5kfj3z7l5hv4fg0g";
+       version = "1.4.6";
+       sha256 = "1gz2mf33lszk33yszzcsbjhch1jxszg1h9cin49wwbgrb0imz7ds";
        libraryHaskellDepends = [
          aeson base containers data-default lens monoid split
          template-haskell
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "list-t_1_0_2" = callPackage
+    ({ mkDerivation, base, base-prelude, HTF, mmorph, monad-control
+     , mtl, mtl-prelude, transformers, transformers-base
+     }:
+     mkDerivation {
+       pname = "list-t";
+       version = "1.0.2";
+       sha256 = "08wjng9d1sqjqc6pgq2lh84gcaabqmrslm3slc0rvaxh1lvasv6s";
+       libraryHaskellDepends = [
+         base mmorph monad-control mtl transformers transformers-base
+       ];
+       testHaskellDepends = [ base-prelude HTF mmorph mtl-prelude ];
+       description = "ListT done right";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "list-t-attoparsec" = callPackage
     ({ mkDerivation, attoparsec, base-prelude, either, hspec, list-t
      , list-t-text, text, transformers
···
     ({ mkDerivation, base }:
      mkDerivation {
        pname = "list-zip-def";
-       version = "0.1.0.2";
-       sha256 = "15123r7a52qb6dcxy1bxid8llykx439srqripmvji3rizwlqaa89";
+       version = "0.1.0.3";
+       sha256 = "0sklydccvdbxnj0c79lj7pcvw5v0bkycs9zp566gdcfy08qcjq79";
        libraryHaskellDepends = [ base ];
        description = "Provides zips with default values";
        license = stdenv.lib.licenses.publicDomain;
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "macos-corelibs" = callPackage
+    ({ mkDerivation, base, containers, managed, mtl, profunctors
+     , tagged, transformers
+     }:
+     mkDerivation {
+       pname = "macos-corelibs";
+       version = "0.0.1.0";
+       sha256 = "1ma5dc8j1s3fpqkqwlqnb32vwchdyabxp001qa7r7balima5xfjs";
+       libraryHaskellDepends = [
+         base containers managed mtl profunctors tagged transformers
+       ];
+       description = "Haskell bindings to C-based Mac OS SDK frameworks";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "macosx-make-standalone" = callPackage
     ({ mkDerivation, base, containers, data-lens, data-lens-template
      , deepseq, directory, filepath, graph-visit, mtl, process
···
      }:
      mkDerivation {
        pname = "mega-sdist";
-       version = "0.3.3.1";
-       sha256 = "0p4n5m91i80cns1g5n18bczpyxm8jcc205syr3k8xd7x9gwg69ww";
-       isLibrary = false;
-       isExecutable = true;
-       executableHaskellDepends = [
-         base bytestring conduit conduit-extra http-conduit optparse-simple
-         rio rio-orphans tar-conduit yaml
-       ];
-       description = "Handles uploading to Hackage from mega repos";
-       license = stdenv.lib.licenses.mit;
-     }) {};
-
-  "mega-sdist_0_3_3_2" = callPackage
-    ({ mkDerivation, base, bytestring, conduit, conduit-extra
-     , http-conduit, optparse-simple, rio, rio-orphans, tar-conduit
-     , yaml
-     }:
-     mkDerivation {
-       pname = "mega-sdist";
        version = "0.3.3.2";
        sha256 = "0jhlaww753spj5k2mrzrizcb408265wglc7gycdicnashsxc7qd4";
        isLibrary = false;
···
        ];
        description = "Handles uploading to Hackage from mega repos";
        license = stdenv.lib.licenses.mit;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "megaparsec" = callPackage
···
        license = stdenv.lib.licenses.publicDomain;
      }) {};
 
+  "mismi-core" = callPackage
+    ({ mkDerivation, amazonka, amazonka-core, base, bytestring
+     , exceptions, hedgehog, http-client, http-types, lens
+     , mismi-core-test, mismi-kernel, mismi-p, mmorph, mtl, resourcet
+     , retry, text, transformers
+     }:
+     mkDerivation {
+       pname = "mismi-core";
+       version = "0.0.1";
+       sha256 = "1vcj56blmk3g7vbp3d3a4yhla002w1ws5jxzbmgf1wxswc8hywvc";
+       libraryHaskellDepends = [
+         amazonka amazonka-core base bytestring exceptions http-client
+         http-types lens mismi-kernel mismi-p mtl resourcet retry text
+         transformers
+       ];
+       testHaskellDepends = [
+         amazonka-core base exceptions hedgehog mismi-core-test mismi-p
+         mmorph resourcet transformers
+       ];
+       description = "AWS Library";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+       broken = true;
+     }) {mismi-core-test = null;};
+
+  "mismi-kernel" = callPackage
+    ({ mkDerivation, base, hedgehog, mismi-p, text }:
+     mkDerivation {
+       pname = "mismi-kernel";
+       version = "0.0.1";
+       sha256 = "1pqm6xza3ds6z5n32bb12q6z2x9n5jzwyxhy7b7f0ryzijasabg4";
+       libraryHaskellDepends = [ base mismi-p text ];
+       testHaskellDepends = [ base hedgehog mismi-p text ];
+       description = "AWS Library";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "mismi-p" = callPackage
+    ({ mkDerivation, base, text }:
+     mkDerivation {
+       pname = "mismi-p";
+       version = "0.0.1";
+       sha256 = "1xkrf270rfjig6bkpk4n63kgmjh05x38p99ndan4gr31ghbjyvk5";
+       libraryHaskellDepends = [ base text ];
+       description = "A commmon prelude for the mismi project";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "mismi-s3-core" = callPackage
+    ({ mkDerivation, attoparsec, base, hedgehog, mismi-p, text }:
+     mkDerivation {
+       pname = "mismi-s3-core";
+       version = "0.0.1";
+       sha256 = "06c7sgkhw7iax6z5cqq1a0icpizwmwl8agvi788h5w2d6hn9wgjh";
+       libraryHaskellDepends = [ attoparsec base mismi-p text ];
+       testHaskellDepends = [ base hedgehog mismi-p text ];
+       description = "AWS Library";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "miso" = callPackage
     ({ mkDerivation, aeson, base, bytestring, containers, http-api-data
      , http-types, lucid, network-uri, servant, servant-lucid, text
···
      }) {};
 
   "modular-arithmetic" = callPackage
-    ({ mkDerivation, base, doctest, Glob }:
+    ({ mkDerivation, base, doctest }:
      mkDerivation {
        pname = "modular-arithmetic";
-       version = "1.2.1.3";
-       sha256 = "1f5k25gqnn037fpan3l956ly0g5cgwnw7qxyc6sm6hgdcl91wn1l";
+       version = "1.2.1.4";
+       sha256 = "1nlv5bwyfppw6qz6j2z1cvgzpixciv5gygpcvqlfnmmv410il4si";
        libraryHaskellDepends = [ base ];
-       testHaskellDepends = [ base doctest Glob ];
+       testHaskellDepends = [ base doctest ];
        description = "A type for integers modulo some constant";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
···
     ({ mkDerivation, base, mtl, transformers }:
      mkDerivation {
        pname = "monad-branch";
-       version = "1.0.3";
-       sha256 = "15nk9lvwz4s6lx8g08x5npai0bk13s6mj26vz6biwy3shpf5v11r";
+       version = "1.0.4";
+       sha256 = "0g82ccql6pmj319ji3zpmxab78qwdlrjsl7cdfhjvv4m1i4kmzdf";
        libraryHaskellDepends = [ base mtl transformers ];
        description = "Monadic abstraction for computations that can be branched and run independently";
        license = stdenv.lib.licenses.asl20;
···
     ({ mkDerivation, base, bindings-monetdb-mapi }:
      mkDerivation {
        pname = "monetdb-mapi";
-       version = "0.1.0.1";
-       sha256 = "1r035w349js424x0864xghvs79v4wsf9br4rwqpfqkyz2hxsqhx0";
+       version = "0.1.0.2";
+       sha256 = "069jmlnrgia36ncl5mqaqq0iaqwrhx6ig5jjnlxr40vfdi4m4dw6";
        libraryHaskellDepends = [ base bindings-monetdb-mapi ];
        description = "Mid-level bindings for the MonetDB API (mapi)";
        license = stdenv.lib.licenses.bsd3;
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "mono-traversable_1_0_10_0" = callPackage
+    ({ mkDerivation, base, bytestring, containers, foldl, gauge
+     , hashable, hspec, HUnit, mwc-random, QuickCheck, semigroups, split
+     , text, transformers, unordered-containers, vector
+     , vector-algorithms
+     }:
+     mkDerivation {
+       pname = "mono-traversable";
+       version = "1.0.10.0";
+       sha256 = "04c8gcksxkrfdll2lm3aaj1dgz7snvfa8avsccs3h6v5ygvdp5h0";
+       revision = "1";
+       editedCabalFile = "1hgwrmq7r8d1nq9283wis67lg0wlid2sgqnr9vpsv2wpnd4n1rdl";
+       libraryHaskellDepends = [
+         base bytestring containers hashable split text transformers
+         unordered-containers vector vector-algorithms
+       ];
+       testHaskellDepends = [
+         base bytestring containers foldl hspec HUnit QuickCheck semigroups
+         text transformers unordered-containers vector
+       ];
+       benchmarkHaskellDepends = [ base gauge mwc-random vector ];
+       description = "Type classes for mapping, folding, and traversing monomorphic containers";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "mono-traversable-instances" = callPackage
     ({ mkDerivation, base, comonad, containers, dlist, dlist-instances
      , mono-traversable, semigroupoids, semigroups, transformers
···
     ({ mkDerivation, base, containers, lens, mtl }:
      mkDerivation {
        pname = "monoid";
-       version = "0.1.8";
-       sha256 = "15mwj4w46wszawhiabykamaf020m795zg017jb2j49gpzk8abqjf";
+       version = "0.1.9";
+       sha256 = "13k5s9y37igvrsfbw5q76zy10fm585dijx10qk32c4agih9fxyfv";
        libraryHaskellDepends = [ base containers lens mtl ];
        description = "Monoid type classes, designed in modular way, distinguish Monoid from Mempty and Semigroup. This design allows mempty operation don't bring Semigroups related constraints until (<>) is used.";
        license = stdenv.lib.licenses.asl20;
···
     ({ mkDerivation, base, containers, hspec }:
      mkDerivation {
        pname = "more-containers";
-       version = "0.1.1.0";
-       sha256 = "1gy7h36spmksn1d3vg56l93kfgd24im304ync20pzaymkbljh1gk";
+       version = "0.1.2.0";
+       sha256 = "0q3ljqjzzrx1y0vbsgvrnmbmvysxkfk2ky5xxix1kirpn1q45yjj";
        libraryHaskellDepends = [ base containers ];
        testHaskellDepends = [ base containers hspec ];
        description = "A few more collections";
···
        libraryHaskellDepends = [ base ];
        description = "Mosquitto client library bindings";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "moss" = callPackage
+    ({ mkDerivation, base, bytestring, conduit-extra, mtl, network
+     , network-simple, unix-compat
+     }:
+     mkDerivation {
+       pname = "moss";
+       version = "0.1.0.0";
+       sha256 = "19gy0x191gk6wa85vp5nhh0xgmr3mj2daiqx8bap452fm1y85qcr";
+       libraryHaskellDepends = [
+         base bytestring conduit-extra mtl network network-simple
+         unix-compat
+       ];
+       description = "Haskell client for Moss";
+       license = stdenv.lib.licenses.mit;
      }) {};
 
   "moto" = callPackage
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "network-uri-lenses" = callPackage
+    ({ mkDerivation, base, lens, network-uri }:
+     mkDerivation {
+       pname = "network-uri-lenses";
+       version = "0.2.0.0";
+       sha256 = "08yvcvpqwibxpqjz3qbkvks1aqgbshdc9chnj8b49yd1vdrzx41p";
+       libraryHaskellDepends = [ base lens network-uri ];
+       description = "Lenses for network-uri";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "network-uri-static" = callPackage
     ({ mkDerivation, base, doctest, network-uri, template-haskell }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "ngx-export-tools";
-       version = "0.4.1.0";
-       sha256 = "0q70p894sqzzx534vxl8grrizllzhw3cx1d02nfg88h7gr82zp3f";
+       version = "0.4.2.1";
+       sha256 = "1hb4n0sjxz6hrdpgw27kxynhvlb8lxf86k4vjjdvic038gf7lfik";
        libraryHaskellDepends = [
          aeson base binary bytestring ngx-export safe template-haskell
        ];
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "notmuch" = callPackage
+    ({ mkDerivation, base, bytestring, c2hs, deepseq, mtl, notmuch
+     , profunctors, tagged, talloc, text, time
+     }:
+     mkDerivation {
+       pname = "notmuch";
+       version = "0.1.0.0";
+       sha256 = "100kqfyw5aan07ywynqrpmgvsv1cma1v7sl2a8zvlwnhva39nz3b";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base bytestring deepseq mtl profunctors tagged text time
+       ];
+       librarySystemDepends = [ notmuch talloc ];
+       libraryToolDepends = [ c2hs ];
+       description = "Haskell binding to Notmuch, the mail indexer";
+       license = stdenv.lib.licenses.gpl3;
+     }) {inherit (pkgs) notmuch; inherit (pkgs) talloc;};
+
   "notmuch-haskell" = callPackage
     ({ mkDerivation, base, containers, filepath, notmuch, old-locale
      , parseargs, time
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "path-io_1_4_0" = callPackage
+  "path-io_1_4_1" = callPackage
     ({ mkDerivation, base, containers, directory, dlist, exceptions
      , filepath, hspec, path, temporary, time, transformers, unix-compat
      }:
      mkDerivation {
        pname = "path-io";
-       version = "1.4.0";
-       sha256 = "0pffdxzn59qm3ifk746sp2g3h2gip2ijs39gwi0k0xn1rkid6ph5";
+       version = "1.4.1";
+       sha256 = "0v5zwdsy8dd2ljidjm2rr8wfpvjlgk1g7c5xf40ddzjn9ghykk2p";
        libraryHaskellDepends = [
          base containers directory dlist exceptions filepath path temporary
          time transformers unix-compat
···
        maintainers = with stdenv.lib.maintainers; [ psibi ];
      }) {inherit (pkgs) sqlite;};
 
-  "persistent-sqlite_2_9_0" = callPackage
+  "persistent-sqlite_2_9_1" = callPackage
     ({ mkDerivation, aeson, base, bytestring, conduit, containers
      , hspec, microlens-th, monad-logger, old-locale, persistent
      , persistent-template, resource-pool, resourcet, sqlite, temporary
···
      }:
      mkDerivation {
        pname = "persistent-sqlite";
-       version = "2.9.0";
-       sha256 = "0yn99m64p49x0bghpbnm77bk3ghk99w2w5d1772cmx15aq2d7w0y";
+       version = "2.9.1";
+       sha256 = "1lh55511zw1zrbvfwbyz18zsm7kb2xsym76f1lp4cdjz37c7sh2j";
        configureFlags = [ "-fsystemlib" ];
        isLibrary = true;
        isExecutable = true;
···
      }:
      mkDerivation {
        pname = "pontarius-xmpp";
-       version = "0.5.4";
-       sha256 = "0fmi915jmdh2k6fp97vywxpbljpcf6xpmvy3m7l1imqig0hfd8nf";
+       version = "0.5.5";
+       sha256 = "044fhp9fa2fp0aka972wmlmfq05k63dc1xb6fqrbwcyaamlprdsp";
+       setupHaskellDepends = [ base Cabal filepath ];
        libraryHaskellDepends = [
          attoparsec base base64-bytestring binary bytestring conduit
          containers crypto-api crypto-random cryptohash cryptohash-cryptoapi
···
      }:
      mkDerivation {
        pname = "posix-paths";
-       version = "0.2.1.5";
-       sha256 = "1pyi25gz2r3pc64f1i5awyp3mg5w74ik9wh5s9i9hs7bfmkjk1as";
+       version = "0.2.1.6";
+       sha256 = "0ibycc7z3gm6jr83cgsqwa7hkky2ldfqqd30ickgq6vn2rkp8fbj";
        libraryHaskellDepends = [ base bytestring unix ];
        testHaskellDepends = [
          base bytestring doctest HUnit QuickCheck unix
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
-  "pretty-show_1_9_2" = callPackage
+  "pretty-show_1_9_4" = callPackage
     ({ mkDerivation, array, base, filepath, ghc-prim, happy
      , haskell-lexer, pretty, text
      }:
      mkDerivation {
        pname = "pretty-show";
-       version = "1.9.2";
-       sha256 = "01vqa5z364cgj73360rpb4rcysfgfyil9l7gxfp96vzcca3gi37a";
+       version = "1.9.4";
+       sha256 = "00gpniygx45yczhkf6ayqik5kraa2c436ragx07mqp3mp383ab5r";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
      }:
      mkDerivation {
        pname = "prologue";
-       version = "3.2.4";
-       sha256 = "0smh3g9k2l4ic9gh1i7aq541nnacipvvc9c0v04xq5rk0rzrswmv";
+       version = "3.2.6";
+       sha256 = "0xic2d3b7ya0qrb8r4q0v6f9zgbh7sw0l7rpbmz09i8pkx7bj90y";
        libraryHaskellDepends = [
          base bifunctors binary comonad cond container convert data-default
          deepseq deriving-compat either errors exceptions functor-utils
···
 
   "proteome" = callPackage
     ({ mkDerivation, aeson, ansi-terminal, base, bytestring, containers
-     , data-default-class, deepseq, directory, filepath, hslogger, HTF
-     , lens, messagepack, MissingH, mtl, nvim-hs, pretty-terminal
-     , prettyprinter, process, resourcet, split, stm, strings, text
-     , time, transformers, unliftio, utf8-string
+     , data-default-class, deepseq, directory, either, filepath
+     , hslogger, HTF, lens, messagepack, MissingH, mtl, nvim-hs
+     , pretty-terminal, prettyprinter, process, resourcet, safe, split
+     , stm, strings, text, time, transformers, unliftio, utf8-string
      }:
      mkDerivation {
        pname = "proteome";
-       version = "0.3.8.0";
-       sha256 = "1lr0a5vyf305ikhzf8xqrdzksz48vjlikx7zvjxkp0wsarz07ikd";
+       version = "0.3.14.0";
+       sha256 = "0mrx51kqz69n8axhzcxfi7x0ddn35ypny2lidas45q0865qgniif";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          aeson ansi-terminal base bytestring containers data-default-class
-         deepseq directory filepath hslogger lens messagepack MissingH mtl
-         nvim-hs pretty-terminal prettyprinter process resourcet split stm
-         strings text time transformers unliftio utf8-string
+         deepseq directory either filepath hslogger lens messagepack
+         MissingH mtl nvim-hs pretty-terminal prettyprinter process
+         resourcet safe split stm strings text time transformers unliftio
+         utf8-string
        ];
        executableHaskellDepends = [
          aeson ansi-terminal base bytestring containers data-default-class
-         deepseq directory filepath hslogger lens messagepack MissingH mtl
-         nvim-hs pretty-terminal prettyprinter process resourcet split stm
-         strings text time transformers unliftio utf8-string
+         deepseq directory either filepath hslogger lens messagepack
+         MissingH mtl nvim-hs pretty-terminal prettyprinter process
+         resourcet safe split stm strings text time transformers unliftio
+         utf8-string
        ];
        testHaskellDepends = [
          aeson ansi-terminal base bytestring containers data-default-class
-         deepseq directory filepath hslogger HTF lens messagepack MissingH
-         mtl nvim-hs pretty-terminal prettyprinter process resourcet split
-         stm strings text time transformers unliftio utf8-string
+         deepseq directory either filepath hslogger HTF lens messagepack
+         MissingH mtl nvim-hs pretty-terminal prettyprinter process
+         resourcet safe split stm strings text time transformers unliftio
+         utf8-string
        ];
        description = "neovim project manager";
        license = stdenv.lib.licenses.mit;
···
        license = stdenv.lib.licenses.bsd3;
      }) {inherit (pkgs) protobuf;};
 
-  "proto-lens-protoc_0_4_0_1" = callPackage
+  "proto-lens-protoc_0_4_0_2" = callPackage
     ({ mkDerivation, base, bytestring, containers, filepath
      , haskell-src-exts, lens-family, pretty, proto-lens, protobuf, text
      }:
      mkDerivation {
        pname = "proto-lens-protoc";
-       version = "0.4.0.1";
-       sha256 = "1vigmy8aq65yaspgq803a4vxsq5v3zwlaq95yrf47zrvcx1lw3ni";
+       version = "0.4.0.2";
+       sha256 = "1kvbv7c42qcynh25mh1vzwdzk4fhvjai031hwmsrmpqywgbgknmm";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "radius";
-       version = "0.5.0.2";
-       sha256 = "08y57j4235ajkf3z05p8lcixgr2x1m6mih5l0bfic4gxfvs818wc";
+       version = "0.6.0.0";
+       sha256 = "02jvlbj3w5ww59ms37l24crr8vib7ghzr9y79bip3p4mhpi4c32l";
        libraryHaskellDepends = [
          base binary bytestring cryptonite iproute memory
        ];
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "recursion-schemes_5_1" = callPackage
+    ({ mkDerivation, base, base-orphans, comonad, free, HUnit
+     , template-haskell, th-abstraction, transformers
+     }:
+     mkDerivation {
+       pname = "recursion-schemes";
+       version = "5.1";
+       sha256 = "1lpk8mkh3vd2j56f0fmaj64indgf5m1db9355fgimcb4xfw13nq1";
+       libraryHaskellDepends = [
+         base base-orphans comonad free template-haskell th-abstraction
+         transformers
+       ];
+       testHaskellDepends = [ base HUnit template-haskell transformers ];
+       description = "Generalized bananas, lenses and barbed wire";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "recursion-schemes-ext" = callPackage
     ({ mkDerivation, base, composition-prelude, criterion, deepseq
      , hspec, lens, recursion-schemes
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "regex_1_0_2_0" = callPackage
+    ({ mkDerivation, array, base, base-compat, bytestring, containers
+     , hashable, regex-base, regex-pcre-builtin, regex-tdfa
+     , regex-tdfa-text, template-haskell, text, time, time-locale-compat
+     , transformers, unordered-containers, utf8-string
+     }:
+     mkDerivation {
+       pname = "regex";
+       version = "1.0.2.0";
+       sha256 = "1f2z025hif1fr24b5khq3qxxyvpxrnhyx8xmbms332arw28rpkda";
+       libraryHaskellDepends = [
+         array base base-compat bytestring containers hashable regex-base
+         regex-pcre-builtin regex-tdfa regex-tdfa-text template-haskell text
+         time time-locale-compat transformers unordered-containers
+         utf8-string
+       ];
+       description = "Toolkit for regex-base";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "regex-applicative" = callPackage
     ({ mkDerivation, base, containers, smallcheck, tasty, tasty-hunit
      , tasty-smallcheck, transformers
···
      }:
      mkDerivation {
        pname = "regex-examples";
-       version = "1.0.1.4";
-       sha256 = "0lxwp1kqacw7dvhbrzy7kl0w5g79gp22b9143m6cgd2f2z7bgzqp";
+       version = "1.0.2.0";
+       sha256 = "0qpf4b2zxdlih1smlhybs923n2gjaxhx8i1rgjw6v7ng13vnriiy";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "regex-with-pcre";
-       version = "1.0.1.4";
-       sha256 = "0pgy9bym4450kzhrzy3amw8dhswzvmqnj5i8pn33l8rvsyr37zp7";
+       version = "1.0.2.0";
+       sha256 = "19vn5w4vhgxv9s6nhlmj4xl8pa16d1a2ygxxyd5b0qg3q27vvisk";
        libraryHaskellDepends = [
          base base-compat bytestring containers regex regex-base
          regex-pcre-builtin regex-pcre-text regex-tdfa template-haskell text
···
      }:
      mkDerivation {
        pname = "registry";
-       version = "0.1.2.0";
-       sha256 = "1y2fvb5qf2gz3nzw983v7r1xgdxxxg0n62sambngf7w8pww5p27d";
+       version = "0.1.2.2";
+       sha256 = "1knhdrjj5y9p8974am4z31k163yjz3123lvjjk1ml4ba65afqhc7";
        libraryHaskellDepends = [
          base exceptions mtl protolude resourcet text transformers-base
        ];
···
        license = stdenv.lib.licenses.bsd3;
      }) {inherit (pkgs) z3;};
 
+  "sbv_7_13" = callPackage
+    ({ mkDerivation, array, async, base, bytestring, containers
+     , crackNum, deepseq, directory, doctest, filepath, generic-deriving
+     , ghc, Glob, hlint, mtl, pretty, process, QuickCheck, random, syb
+     , tasty, tasty-golden, tasty-hunit, tasty-quickcheck
+     , template-haskell, time, z3
+     }:
+     mkDerivation {
+       pname = "sbv";
+       version = "7.13";
+       sha256 = "0bk400swnb4s98c5p71ml1px6jndaiqhf5dj7zmnliyplqcgpfik";
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         array async base containers crackNum deepseq directory filepath
+         generic-deriving ghc mtl pretty process QuickCheck random syb
+         template-haskell time
+       ];
+       testHaskellDepends = [
+         base bytestring containers crackNum directory doctest filepath Glob
+         hlint mtl QuickCheck random syb tasty tasty-golden tasty-hunit
+         tasty-quickcheck template-haskell
+       ];
+       testSystemDepends = [ z3 ];
+       description = "SMT Based Verification: Symbolic Haskell theorem prover using SMT solving";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {inherit (pkgs) z3;};
+
   "sbvPlugin" = callPackage
     ({ mkDerivation, base, containers, directory, filepath, ghc
      , ghc-prim, mtl, process, sbv, tasty, tasty-golden
···
      }:
      mkDerivation {
        pname = "semilattices";
-       version = "0.0.0.2";
-       sha256 = "1f4xy2kl8mqvlrzv8y0qs2i3c095iprbzpa4j424sifsmms3ya89";
+       version = "0.0.0.3";
+       sha256 = "089vgwbcwa3hj53hh9djmilwfknsd9g9z9q1gbl0dad4lr39062f";
        libraryHaskellDepends = [
          base containers hashable unordered-containers
        ];
···
        pname = "servant-auth-server";
        version = "0.4.2.0";
        sha256 = "000szizds1c8amxm7gl75gpwrlj38gv665bhp59d35wcq03na4ap";
-       revision = "2";
-       editedCabalFile = "188chzggs5ahc2v1mxrr5cda5dqjwwar8b85yz7ysvlvbxb1zsb3";
+       revision = "3";
+       editedCabalFile = "1zjxqlfyw3wwlyq2faiq9gqhfixn2mvfsv8dapalxs9fph7a2nzj";
        libraryHaskellDepends = [
          aeson base base64-bytestring blaze-builder bytestring
          bytestring-conversion case-insensitive cookie crypto-api
···
     ({ mkDerivation, base, text }:
      mkDerivation {
        pname = "shortcut-links";
-       version = "0.4.2.0";
-       sha256 = "09sh6c1cwhs9x49mim8z1pafb0sh1z3im0k5wvigkpagx72pasqy";
+       version = "0.4.2.1";
+       sha256 = "1zyy4jma61vg684sa66mpdlq9ylfrfv23d8m0163lbcfpkxfqdhd";
        libraryHaskellDepends = [ base text ];
        description = "Link shortcuts for use in text markup";
        license = stdenv.lib.licenses.bsd3;
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "skip-var" = callPackage
+    ({ mkDerivation, base }:
+     mkDerivation {
+       pname = "skip-var";
+       version = "0.1.0.0";
+       sha256 = "1xwbr25nsjkjvwjh62inr3ja7lp7carmc4nd68ybkyxmcfp1ivmc";
+       libraryHaskellDepends = [ base ];
+       description = "Skip variables";
+       license = stdenv.lib.licenses.mit;
+     }) {};
+
   "skulk" = callPackage
     ({ mkDerivation, base, hspec, QuickCheck }:
      mkDerivation {
···
   "snap" = callPackage
     ({ mkDerivation, aeson, async, attoparsec, base, bytestring, cereal
      , clientsession, configurator, containers, deepseq, directory
-     , directory-tree, dlist, filepath, hashable, heist, http-streams
-     , HUnit, lens, lifted-base, map-syntax, monad-control, mtl
-     , mwc-random, pwstore-fast, QuickCheck, smallcheck, snap-core
+     , directory-tree, dlist, fail, filepath, hashable, heist
+     , http-streams, HUnit, lens, lifted-base, map-syntax, monad-control
+     , mtl, mwc-random, pwstore-fast, QuickCheck, smallcheck, snap-core
      , snap-server, stm, syb, test-framework, test-framework-hunit
      , test-framework-quickcheck2, test-framework-smallcheck, text, time
      , transformers, transformers-base, unordered-containers, xmlhtml
      }:
      mkDerivation {
        pname = "snap";
-       version = "1.1.1.0";
-       sha256 = "08kgvry18kfkspif2xn8j7w9jfinhrnl33g6ap74fz7rsrg68jz7";
+       version = "1.1.2.0";
+       sha256 = "05da0dg0p6djcsinycih50hjnircibmicarwg2vr14a7zbrhynps";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring cereal clientsession configurator
-         containers directory directory-tree dlist filepath hashable heist
-         lens lifted-base map-syntax monad-control mtl mwc-random
+         containers directory directory-tree dlist fail filepath hashable
+         heist lens lifted-base map-syntax monad-control mtl mwc-random
          pwstore-fast snap-core snap-server stm text time transformers
          transformers-base unordered-containers xmlhtml
        ];
        testHaskellDepends = [
          aeson async attoparsec base bytestring cereal clientsession
-         configurator containers deepseq directory directory-tree dlist
+         configurator containers deepseq directory directory-tree dlist fail
          filepath hashable heist http-streams HUnit lens lifted-base
          map-syntax monad-control mtl mwc-random pwstore-fast QuickCheck
          smallcheck snap-core snap-server stm syb test-framework
···
        pname = "snap-loader-dynamic";
        version = "1.0.0.0";
        sha256 = "12zvmdkypwflmc81i0sxbfmb3ja0vydycmaliyvrw0z32kg705wg";
-       revision = "3";
-       editedCabalFile = "0kk3viaz5hikj9815ja9l3fqq3653vx7q9jamkz68hyfxyvf8qxh";
+       revision = "4";
+       editedCabalFile = "19bi4vh6pvcm0qc4wz0ydhs9flii6hyzg7z3iiijfcyhdcc9iah9";
        libraryHaskellDepends = [
          base directory directory-tree hint mtl snap-core template-haskell
          time unix
···
 
   "sproxy2" = callPackage
     ({ mkDerivation, aeson, base, base64-bytestring, blaze-builder
-     , bytestring, cereal, conduit, containers, cookie, docopt, entropy
-     , Glob, http-client, http-conduit, http-types
-     , interpolatedstring-perl6, network, postgresql-simple
-     , resource-pool, SHA, sqlite-simple, text, time, unix
-     , unordered-containers, wai, wai-conduit, warp, warp-tls, word8
-     , yaml
+     , bytestring, cereal, conduit, cookie, docopt, entropy, Glob
+     , http-client, http-conduit, http-types, interpolatedstring-perl6
+     , network, postgresql-simple, resource-pool, SHA, sqlite-simple
+     , text, time, unix, unordered-containers, wai, wai-conduit, warp
+     , warp-tls, word8, yaml
      }:
      mkDerivation {
        pname = "sproxy2";
-       version = "1.96.0";
-       sha256 = "0wzkh312d7h957vkf2qqsbnf9xm98vm8y5kzray87rn6rdc5k5x6";
+       version = "1.97.0";
+       sha256 = "1in8sb41bl46xwk49904xkm3k5s59xikvmyyani1p60l0zfrb2jk";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
          aeson base base64-bytestring blaze-builder bytestring cereal
-         conduit containers cookie docopt entropy Glob http-client
-         http-conduit http-types interpolatedstring-perl6 network
-         postgresql-simple resource-pool SHA sqlite-simple text time unix
-         unordered-containers wai wai-conduit warp warp-tls word8 yaml
+         conduit cookie docopt entropy Glob http-client http-conduit
+         http-types interpolatedstring-perl6 network postgresql-simple
+         resource-pool SHA sqlite-simple text time unix unordered-containers
+         wai wai-conduit warp warp-tls word8 yaml
        ];
        description = "Secure HTTP proxy for authenticating users via OAuth2";
        license = stdenv.lib.licenses.mit;
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "stack2cabal" = callPackage
+    ({ mkDerivation, base, bytestring, Cabal, directory, filepath
+     , hpack, stackage-to-hackage, text
+     }:
+     mkDerivation {
+       pname = "stack2cabal";
+       version = "1.0.0";
+       sha256 = "0pqyf8jpldb733i0g93z5w1r6rgxgdnswkd2ciw8pbq5dw38q2yf";
+       isLibrary = false;
+       isExecutable = true;
+       executableHaskellDepends = [
+         base bytestring Cabal directory filepath hpack stackage-to-hackage
+         text
+       ];
+       description = "Convert stack projects to cabal.project + cabal.project.freeze";
+       license = stdenv.lib.licenses.gpl3Plus;
+     }) {};
+
   "stack2nix" = callPackage
     ({ mkDerivation, async, base, Cabal, cabal2nix, containers
      , directory, distribution-nixpkgs, filepath, hackage-db, hspec
···
 
   "stackage-to-hackage" = callPackage
     ({ mkDerivation, base, bytestring, Cabal, containers, directory
-     , extra, filepath, HsOpenSSL, HsYAML, http-streams, network-uri
-     , optparse-applicative, semigroupoids, text
+     , extra, filepath, HsYAML, http-client, http-client-tls
+     , optparse-applicative, text
      }:
      mkDerivation {
        pname = "stackage-to-hackage";
-       version = "1.0.2";
-       sha256 = "0s474q0hwz917vhh9hmx33j9jjbgm58ajgl0wacw8hfbs8awwk20";
-       isLibrary = false;
+       version = "1.1.0";
+       sha256 = "165g5vyxck8hh2523v4h0cwjl3yvp4wwzlsdrs9wvg9ca3ij0v85";
+       isLibrary = true;
        isExecutable = true;
+       libraryHaskellDepends = [
+         base bytestring Cabal containers directory extra filepath HsYAML
+         http-client http-client-tls text
+       ];
        executableHaskellDepends = [
-         base bytestring Cabal containers directory extra filepath HsOpenSSL
-         HsYAML http-streams network-uri optparse-applicative semigroupoids
-         text
+         base bytestring Cabal containers directory extra filepath
+         optparse-applicative text
        ];
        description = "Convert stack.yaml to cabal.project + cabal.project.freeze";
        license = stdenv.lib.licenses.gpl3Plus;
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
-  "stratosphere_0_28_1" = callPackage
+  "stratosphere_0_29_0" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, base, bytestring, containers
      , hashable, hspec, hspec-discover, lens, template-haskell, text
      , unordered-containers
      }:
      mkDerivation {
        pname = "stratosphere";
-       version = "0.28.1";
-       sha256 = "1brypavqh8049adidzgsjsrfd2sxbv387cckwxl4kkm4s49zrx18";
+       version = "0.29.0";
+       sha256 = "0zncpgjklm649fzrjjy0bri0ivybrc7lvys8yq72b4dpb8ksp5zs";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "stripe-concepts" = callPackage
+    ({ mkDerivation, base, bytestring, text }:
+     mkDerivation {
+       pname = "stripe-concepts";
+       version = "1.0.0.0";
+       sha256 = "0s518mlb181407w2gmlhaayaf3ypn03lzw3fmkzkiqz2c89kd1rw";
+       libraryHaskellDepends = [ base bytestring text ];
+       description = "Types for the Stripe API";
+       license = stdenv.lib.licenses.mit;
+     }) {};
+
   "stripe-core" = callPackage
     ({ mkDerivation, aeson, base, bytestring, mtl, text, time
      , transformers, unordered-containers
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "stripe-scotty" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, http-types, scotty
+     , stripe-concepts, stripe-signature, text, unordered-containers
+     }:
+     mkDerivation {
+       pname = "stripe-scotty";
+       version = "1.0.0.0";
+       sha256 = "195v1a3sl5skz2jr71r1b4za033s6hib7ld59f4fdrfdr5658sbs";
+       revision = "1";
+       editedCabalFile = "0c3r39217650yjxxs1523ywvyiirrh2f209gl4hfznyigkx2kg41";
+       libraryHaskellDepends = [
+         aeson base bytestring http-types scotty stripe-concepts
+         stripe-signature text unordered-containers
+       ];
+       description = "Listen for Stripe webhook events with Scotty";
+       license = stdenv.lib.licenses.mit;
+     }) {};
+
+  "stripe-signature" = callPackage
+    ({ mkDerivation, base, bytestring, cryptonite, hex-text, memory
+     , stripe-concepts, text
+     }:
+     mkDerivation {
+       pname = "stripe-signature";
+       version = "1.0.0.0";
+       sha256 = "0hg5l9fyfr6yhna2awcyrfr38zlpd1q58b6q6fc3aq8qhbwk8zps";
+       libraryHaskellDepends = [
+         base bytestring cryptonite hex-text memory stripe-concepts text
+       ];
+       testHaskellDepends = [ base bytestring text ];
+       description = "Verification of Stripe webhook signatures";
+       license = stdenv.lib.licenses.mit;
+     }) {};
+
   "stripe-tests" = callPackage
     ({ mkDerivation, aeson, base, bytestring, free, hspec, hspec-core
      , mtl, random, stripe-core, text, time, transformers
···
        description = "Tests for Stripe API bindings for Haskell";
        license = stdenv.lib.licenses.mit;
        hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
+  "stripe-wreq" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, lens, stripe-concepts
+     , text, unordered-containers, wreq
+     }:
+     mkDerivation {
+       pname = "stripe-wreq";
+       version = "1.0.0.0";
+       sha256 = "1cm9fvkpanxydbbrk9s1yj3bkxd7wcschi40a4dhmh8h3wr89y8s";
+       libraryHaskellDepends = [
+         aeson base bytestring lens stripe-concepts text
+         unordered-containers wreq
+       ];
+       description = "Use the Stripe API via Wreq";
+       license = stdenv.lib.licenses.mit;
      }) {};
 
   "strips" = callPackage
···
      }) {};
 
   "supervisors" = callPackage
-    ({ mkDerivation, async, base, containers, hspec, stm, unliftio }:
+    ({ mkDerivation, async, base, containers, hspec, safe-exceptions
+     , stm
+     }:
      mkDerivation {
        pname = "supervisors";
-       version = "0.1.0.0";
-       sha256 = "1sxralp0hcz2zn5byn67xq612nzmpm890gnjs827sidvr7r7h31j";
-       revision = "2";
-       editedCabalFile = "08qz4qbfrj7hpk3pgyjy3r149dz48jpxajyjs10fgiz16xg11zyl";
-       libraryHaskellDepends = [ async base containers stm unliftio ];
+       version = "0.2.0.0";
+       sha256 = "0q6r211sbb9dyrplr61xajbwcfvz7z93401mhqxhw3pz55vyrg8i";
+       libraryHaskellDepends = [
+         async base containers safe-exceptions stm
+       ];
        testHaskellDepends = [ base hspec ];
        description = "Monitor groups of threads with non-hierarchical lifetimes";
        license = stdenv.lib.licenses.mit;
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "tasty-ant-xml_1_1_5" = callPackage
+    ({ mkDerivation, base, containers, directory, filepath
+     , generic-deriving, ghc-prim, mtl, stm, tagged, tasty, transformers
+     , xml
+     }:
+     mkDerivation {
+       pname = "tasty-ant-xml";
+       version = "1.1.5";
+       sha256 = "1px562a9c3vn0qxy8zs8mkp73nfqca17hdwhv5p7qgawpjafxk32";
+       libraryHaskellDepends = [
+         base containers directory filepath generic-deriving ghc-prim mtl
+         stm tagged tasty transformers xml
+       ];
+       description = "Render tasty output to XML for Jenkins";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "tasty-auto" = callPackage
     ({ mkDerivation, base, directory, filepath, tasty, tasty-hspec
      , tasty-hunit, tasty-quickcheck, tasty-smallcheck
···
        description = "TAP (Test Anything Protocol) Version 13 formatter for tasty";
        license = stdenv.lib.licenses.mit;
        hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
+  "tasty-test-vector" = callPackage
+    ({ mkDerivation, base, tasty }:
+     mkDerivation {
+       pname = "tasty-test-vector";
+       version = "0";
+       sha256 = "1kgz9mp1h391rqj9n78bfvxl8pd3bxanbnwkc5l9gvlygly3fz8j";
+       libraryHaskellDepends = [ base tasty ];
+       description = "Test vector support for tasty";
+       license = stdenv.lib.licenses.bsd3;
      }) {};
 
   "tasty-th" = callPackage
···
      }:
      mkDerivation {
        pname = "terminal-text";
-       version = "1.1.1";
-       sha256 = "1jgdxqck3ck65mppi694w0f5x0547148y5agi100zggp8r3yxsy3";
+       version = "1.1.2";
+       sha256 = "1cfxkx3mfjxw8fh3gw4wqk5wwf10hi1aldhn6xc75mwfa6x7djjq";
        libraryHaskellDepends = [
          ansi-terminal base container layered-state prologue text
        ];
···
        license = stdenv.lib.licenses.isc;
      }) {};
 
+  "th-abstraction_0_2_10_0" = callPackage
+    ({ mkDerivation, base, containers, ghc-prim, template-haskell }:
+     mkDerivation {
+       pname = "th-abstraction";
+       version = "0.2.10.0";
+       sha256 = "1bql46ylr111g0pncdsf5mbhn6cpaw9xlqby89bz417dlk5gzny9";
+       libraryHaskellDepends = [
+         base containers ghc-prim template-haskell
+       ];
+       testHaskellDepends = [ base containers template-haskell ];
+       description = "Nicer interface for reified information about data types";
+       license = stdenv.lib.licenses.isc;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "th-alpha" = callPackage
     ({ mkDerivation, base, containers, derive, mmorph, mtl, tasty
      , tasty-hunit, tasty-quickcheck, template-haskell, th-desugar
···
      }) {};
 
   "tidal" = callPackage
-    ({ mkDerivation, base, colour, containers, hashable, hosc
-     , mersenne-random-pure64, monad-loops, mtl, parsec, safe, tasty
-     , tasty-hunit, text, time, websockets
+    ({ mkDerivation, base, bifunctors, colour, containers, hashable
+     , hosc, microspec, monad-loops, mtl, mwc-random, network, parsec
+     , random, safe, text, time, vector
      }:
      mkDerivation {
        pname = "tidal";
-       version = "0.9.10";
-       sha256 = "1fgana79fwmn2s3b50vs9wlri6z4f2b8lad5m4n4ggc4rginvlkw";
+       version = "1.0.3";
+       sha256 = "1blzlahn1xsp03wiv7ci4n6795xx8i9syhclbgcx6fy6gkfr2wy2";
        libraryHaskellDepends = [
-         base colour containers hashable hosc mersenne-random-pure64
-         monad-loops mtl parsec safe text time websockets
+         base bifunctors colour containers hashable hosc monad-loops mtl
+         mwc-random network parsec random safe text time vector
        ];
-       testHaskellDepends = [ base tasty tasty-hunit ];
+       testHaskellDepends = [ base containers microspec parsec ];
        description = "Pattern language for improvised music";
        license = stdenv.lib.licenses.gpl3;
      }) {};
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "turtle_1_5_13" = callPackage
+    ({ mkDerivation, ansi-wl-pprint, async, base, bytestring, clock
+     , containers, criterion, directory, doctest, exceptions, foldl
+     , hostname, managed, optional-args, optparse-applicative, process
+     , semigroups, stm, system-fileio, system-filepath, temporary, text
+     , time, transformers, unix, unix-compat
+     }:
+     mkDerivation {
+       pname = "turtle";
+       version = "1.5.13";
+       sha256 = "1124yhw0l8924cwkmap1qn2z0hf4vn3r73h4pmi9icahg8zpc1hg";
+       libraryHaskellDepends = [
+         ansi-wl-pprint async base bytestring clock containers directory
+         exceptions foldl hostname managed optional-args
+         optparse-applicative process semigroups stm system-fileio
+         system-filepath temporary text time transformers unix unix-compat
+       ];
+       testHaskellDepends = [ base doctest system-filepath temporary ];
+       benchmarkHaskellDepends = [ base criterion text ];
+       description = "Shell programming, Haskell-style";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "turtle-options" = callPackage
     ({ mkDerivation, base, HUnit, optional-args, parsec, text, turtle
      }:
···
        pname = "type-level-sets";
        version = "0.8.9.0";
        sha256 = "1acsr7g9ssli9yil9kws47gc6h3csmk2afncyki41pipa1vsriv4";
+       revision = "1";
+       editedCabalFile = "0cc0ws2plharq0gvindgmkp1fs82zd43zijkh7wf0ilfnr2l17z2";
        libraryHaskellDepends = [ base ghc-prim ];
        description = "Type-level sets and finite maps (with value-level counterparts)";
        license = stdenv.lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "type-map";
-       version = "0.1.3.0";
-       sha256 = "146kc36z6fljcgmgl9vii1pmf3hs80v2vz21r84p823znrqjs8gc";
+       version = "0.1.4.0";
+       sha256 = "16ccnn5dk6wl2ynwwmc71rr64qpppqxlmxahmj5g3plq8hh0p40d";
        libraryHaskellDepends = [ base containers ghc-prim vector ];
        testHaskellDepends = [
          base HUnit test-framework test-framework-hunit
···
      }:
      mkDerivation {
        pname = "typed-spreadsheet";
-       version = "1.1.3";
-       sha256 = "1y59kd92f5v116y26dlznvqi5kcb6y89rliwcs8ay9sk76606fa6";
+       version = "1.1.4";
+       sha256 = "16xbzwaiakimwwkbb0q0nxa08j7842z3894p04ijjvksllkdrlna";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "typelevel";
-       version = "1.2.2";
-       sha256 = "0baigk89rd5cdy35v3abvdwh7g11fnz2rpnzfy4ahr0q1lj395f5";
+       version = "1.2.3";
+       sha256 = "02bvzgl0331xa4pwdclw08wyq8canmw06ps3xvgvhb5miy93rrwz";
        libraryHaskellDepends = [
          base constraints convert exceptions lens mtl pretty pretty-show
          primitive transformers
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "unix-time_0_4_0" = callPackage
-    ({ mkDerivation, base, binary, bytestring, doctest, hspec
-     , old-locale, old-time, QuickCheck, time
+  "unix-time_0_4_3" = callPackage
+    ({ mkDerivation, base, binary, bytestring, Cabal, cabal-doctest
+     , doctest, hspec, old-locale, old-time, QuickCheck, time
      }:
      mkDerivation {
        pname = "unix-time";
-       version = "0.4.0";
-       sha256 = "0fb9mdg596db9wbxsr5m3zc3wasvwblb32fsva0zrac93c9rq51r";
+       version = "0.4.3";
+       sha256 = "0h95vmsk7qyk9nbgjm5vi32ikdw07p1z0l7k6b5hbsv3wavivm53";
+       setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [ base binary bytestring old-time ];
        testHaskellDepends = [
          base bytestring doctest hspec old-locale old-time QuickCheck time
···
      }) {};
 
   "unliftio" = callPackage
-    ({ mkDerivation, async, base, deepseq, directory, filepath, hspec
-     , process, stm, time, transformers, unix, unliftio-core
-     }:
-     mkDerivation {
-       pname = "unliftio";
-       version = "0.2.8.1";
-       sha256 = "18v8rzm2nxpck5xvg8qixkarhliy16yswgvj6vbjzq8bn4n6nydz";
-       revision = "1";
-       editedCabalFile = "1zx2h1mnjcjszjdchg17gqrnj3d56x46947jm92snmdjw8x231wg";
-       libraryHaskellDepends = [
-         async base deepseq directory filepath process stm time transformers
-         unix unliftio-core
-       ];
-       testHaskellDepends = [
-         async base deepseq directory filepath hspec process stm time
-         transformers unix unliftio-core
-       ];
-       description = "The MonadUnliftIO typeclass for unlifting monads to IO (batteries included)";
-       license = stdenv.lib.licenses.mit;
-     }) {};
-
-  "unliftio_0_2_9_0" = callPackage
     ({ mkDerivation, async, base, deepseq, directory, filepath, gauge
      , hspec, process, QuickCheck, stm, time, transformers, unix
      , unliftio-core
···
        ];
        description = "The MonadUnliftIO typeclass for unlifting monads to IO (batteries included)";
        license = stdenv.lib.licenses.mit;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "unliftio-core" = callPackage
···
        pname = "uuid-crypto";
        version = "1.4.0.0";
        sha256 = "191da0bdgzbpibh7v2n2cg13gkq2vchsybad0qy9qixk0rzi1cvn";
-       revision = "4";
-       editedCabalFile = "1rzvpkvjbvzwvks795998k8232pc41yvcblrq7f29abrvd0587xp";
+       revision = "6";
+       editedCabalFile = "146jxyrsnrcwsll6mhq8a67ms1wpbbbxmkbq7sh9wza6c4g2fbwy";
        libraryHaskellDepends = [
          base binary bytestring cryptoids cryptoids-class cryptoids-types
          exceptions uuid
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "vector-sized_1_1_1_0" = callPackage
+  "vector-sized_1_2_0_0" = callPackage
     ({ mkDerivation, adjunctions, base, comonad, deepseq, distributive
-     , finite-typelits, indexed-list-literals, primitive, vector
+     , finite-typelits, hashable, indexed-list-literals, primitive
+     , vector
      }:
      mkDerivation {
        pname = "vector-sized";
-       version = "1.1.1.0";
-       sha256 = "05rrfiy0zzcq5jmr1kfbpv1p6f35pqsd5k6zf78byznzjwk758nb";
+       version = "1.2.0.0";
+       sha256 = "04r43b30vayg56n88b5r3b5krh2kjxnqgmr4kx052bgpl8k6zh54";
        libraryHaskellDepends = [
          adjunctions base comonad deepseq distributive finite-typelits
-         indexed-list-literals primitive vector
+         hashable indexed-list-literals primitive vector
        ];
        description = "Size tagged vectors";
        license = stdenv.lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "vector-text";
-       version = "1.1.5";
-       sha256 = "1gd7dg9icr1211rf298ny60yjgyyxbxa62l16q28yd5z160sr3ir";
+       version = "1.1.6";
+       sha256 = "14ms8ach15c1pyaih92qi703vj9aanbrmcsfwzxb55vwfpbbm2f4";
        libraryHaskellDepends = [
          base binary prologue text vector vector-binary-instances
        ];
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "viewprof_0_0_0_26" = callPackage
+    ({ mkDerivation, base, brick, containers, directory, ghc-prof, lens
+     , scientific, text, vector, vector-algorithms, vty
+     }:
+     mkDerivation {
+       pname = "viewprof";
+       version = "0.0.0.26";
+       sha256 = "11nd137135jq19l58g5fkxzznbv2hdrfyy231fy9s8hifm2rz14d";
+       isLibrary = false;
+       isExecutable = true;
+       executableHaskellDepends = [
+         base brick containers directory ghc-prof lens scientific text
+         vector vector-algorithms vty
+       ];
+       description = "Text-based interactive GHC .prof viewer";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "views" = callPackage
     ({ mkDerivation, base, mtl }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "waargonaut";
-       version = "0.4.2.0";
-       sha256 = "19zfzff6cp57xv220yyxfi0j36x1qic7v4sa93yclshyjmhm7vnm";
+       version = "0.5.0.0";
+       sha256 = "0xa9ql4583z9cwkn76sf41igk0ny8yp8fcgs6lwbk7kfbb54kk4b";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [
          base bifunctors bytestring containers contravariant digit
···
        testHaskellDepends = [ base doctest ];
        description = "A logging system for WAI";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "wai-logger_2_3_3" = callPackage
+    ({ mkDerivation, base, byteorder, bytestring, Cabal, cabal-doctest
+     , doctest, fast-logger, http-types, network, wai
+     }:
+     mkDerivation {
+       pname = "wai-logger";
+       version = "2.3.3";
+       sha256 = "1i200kn3cnd1b3hf53982y6rddwrf3z1acbclf1xc15632df73wx";
+       setupHaskellDepends = [ base Cabal cabal-doctest ];
+       libraryHaskellDepends = [
+         base byteorder bytestring fast-logger http-types network wai
+       ];
+       testHaskellDepends = [ base doctest ];
+       description = "A logging system for WAI";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "wai-logger-buffered" = callPackage
···
      }:
      mkDerivation {
        pname = "wreq";
-       version = "0.5.3.0";
-       sha256 = "1bi78y0jzm8mvwbfc4mphg8iyjz5v1f4ziqpk1dskvb1f3ysw3d9";
-       isLibrary = true;
-       isExecutable = true;
-       setupHaskellDepends = [ base Cabal cabal-doctest ];
-       libraryHaskellDepends = [
-         aeson attoparsec authenticate-oauth base base16-bytestring
-         bytestring case-insensitive containers cryptonite exceptions
-         ghc-prim hashable http-client http-client-tls http-types lens
-         lens-aeson memory mime-types psqueues template-haskell text time
-         time-locale-compat unordered-containers
-       ];
-       testHaskellDepends = [
-         aeson aeson-pretty base base64-bytestring bytestring
-         case-insensitive containers directory doctest filepath hashable
-         http-client http-types HUnit lens lens-aeson network-info
-         QuickCheck snap-core snap-server temporary test-framework
-         test-framework-hunit test-framework-quickcheck2 text time
-         transformers unix-compat unordered-containers uuid vector
-       ];
-       description = "An easy-to-use HTTP client library";
-       license = stdenv.lib.licenses.bsd3;
-     }) {};
-
-  "wreq_0_5_3_1" = callPackage
-    ({ mkDerivation, aeson, aeson-pretty, attoparsec
-     , authenticate-oauth, base, base16-bytestring, base64-bytestring
-     , bytestring, Cabal, cabal-doctest, case-insensitive, containers
-     , cryptonite, directory, doctest, exceptions, filepath, ghc-prim
-     , hashable, http-client, http-client-tls, http-types, HUnit, lens
-     , lens-aeson, memory, mime-types, network-info, psqueues
-     , QuickCheck, snap-core, snap-server, template-haskell, temporary
-     , test-framework, test-framework-hunit, test-framework-quickcheck2
-     , text, time, time-locale-compat, transformers, unix-compat
-     , unordered-containers, uuid, vector
-     }:
-     mkDerivation {
-       pname = "wreq";
        version = "0.5.3.1";
        sha256 = "1i2f2bxx84l8qzkz9v3qhx5sbl78ysc3vqadfhrxk3h0ljklwfz3";
        isLibrary = true;
···
        ];
        description = "An easy-to-use HTTP client library";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "wreq-sb" = callPackage
···
      }:
      mkDerivation {
        pname = "wsjtx-udp";
-       version = "0.1.3.4";
-       sha256 = "0krn5ams62dh4f0gfyx7ss7ymm438s9bf4m329pqnhj11p2fiazf";
+       version = "0.1.3.5";
+       sha256 = "1x2975pj2i0c4w1s00s4qc24sa24y29magilfxbhy8v1w1hfqcv7";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "yesod-bin";
        version = "1.6.0.3";
        sha256 = "1p5f6bl4gynm47m1xg1x1xh9nz913i83iprh2xd207359idjknz4";
-       revision = "3";
-       editedCabalFile = "0v3bwg26ghxa1wdvwyvrffd8wwxhv1qk9g8f64ax1n8gz53k6an7";
+       revision = "4";
+       editedCabalFile = "1iw9m3z6m4n9dlwamf1kwr7pp2wpk6awf1m63zjkgw5j4vwxlcpg";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "yx" = callPackage
+    ({ mkDerivation, array, base, bytestring, hspec }:
+     mkDerivation {
+       pname = "yx";
+       version = "0.0.2.0";
+       sha256 = "05xh7x02ddh87kwslgckzh3g5i22r01vfrb160gns3zl6fv8sj2z";
+       libraryHaskellDepends = [ array base bytestring ];
+       testHaskellDepends = [ array base bytestring hspec ];
+       description = "Row-major coordinates";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "yxdb-utils" = callPackage
     ({ mkDerivation, array, attoparsec, base, bimap, binary
      , binary-conduit, bytestring, Codec-Compression-LZF, conduit
···
        description = "Haskell bindings to the Zstandard compression algorithm";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
+  "zsyntax" = callPackage
+    ({ mkDerivation, base, constraints, containers, mtl, multiset }:
+     mkDerivation {
+       pname = "zsyntax";
+       version = "0.2.0.0";
+       sha256 = "1pv2slz9r305lal25gh5zhr0lnkf4nzsg6vib6i576m83d3pcsgx";
+       libraryHaskellDepends = [
+         base constraints containers mtl multiset
+       ];
+       testHaskellDepends = [ base containers mtl multiset ];
+       description = "Automated theorem prover for the Zsyntax biochemical calculus";
+       license = stdenv.lib.licenses.bsd3;
      }) {};
 
   "ztail" = callPackage

pkgs/development/idris-modules/tparsec.nix

···
 }:
 build-idris-package  {
   name = "tparsec";
-  version = "2018-06-26";
+  version = "2018-11-09";
 
   ipkgName = "TParsec";
 
   src = fetchFromGitHub {
     owner = "gallais";
     repo = "idris-tparsec";
-    rev = "ca32d1a83f3de95f8979d48016e79d010f47b3c2";
-    sha256 = "1zjzk8xjmyyx1qwrdwwg7yjzcgj5wkbwpx8a3wpbj5sv4b5s2r30";
+    rev = "fc5bc1e0bf21a53ec854990ed799c4c73e304b06";
+    sha256 = "0ladks6x1qhs884w4rsxnzpq8dpijyqfqbvhk55kq10xh6w1smrz";
   };
 
   meta = {

pkgs/development/interpreters/angelscript/2.22.nix

···
     license = stdenv.lib.licenses.zlib ;
     maintainers = [stdenv.lib.maintainers.raskin];
     platforms = stdenv.lib.platforms.linux;
+    badPlatforms = [ "aarch64-linux" ];
     downloadPage = "http://www.angelcode.com/angelscript/downloads.html";
     homepage="http://www.angelcode.com/angelscript/";
   };

pkgs/development/interpreters/clojure/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "clojure-${version}";
-  version = "1.9.0.391";
+  version = "1.10.0.403";
 
   src = fetchurl {
     url = "https://download.clojure.org/install/clojure-tools-${version}.tar.gz";
-    sha256 = "1720nbp891mhdjp37z1ns7rg8yapk3a7h1a1rkzhx7abngpwwjcz";
+    sha256 = "0jsyd0vr1qfqs0dz560hyfya553jhr4m4msf5x0n610yzvbqym4c";
   };
 
   buildInputs = [ makeWrapper ];
···
     substituteInPlace clojure --replace PREFIX $prefix
 
     install -Dt $out/bin clj clojure
-    wrapProgram $out/bin/clj --prefix PATH : ${binPath}
-    wrapProgram $out/bin/clojure --prefix PATH : ${binPath}
+    wrapProgram $out/bin/clj --prefix PATH : $out/bin:${binPath}
+    wrapProgram $out/bin/clojure --prefix PATH : $out/bin:${binPath}
   '';
 
   meta = with stdenv.lib; {

pkgs/development/interpreters/python/mk-python-derivation.nix

···
   } // meta;
 }));
 
-passthru = {
-  updateScript = let
+passthru.updateScript = let
     filename = builtins.head (lib.splitString ":" self.meta.position);
-  in writeScript "update-python" ''
-    #!${python.stdenv.shell}
-    ${update-python-libraries} ${filename}
-  '';
-};
+  in attrs.passthru.updateScript or [ update-python-libraries filename ];
 in lib.extendDerivation true passthru self

pkgs/development/interpreters/python/pypy/3/default.nix

···
+{ stdenv, substituteAll, fetchurl
+, zlib ? null, zlibSupport ? true, bzip2, pkgconfig, libffi
+, sqlite, openssl, ncurses, python, expat, tcl, tk, tix, xlibsWrapper, libX11
+, makeWrapper, callPackage, self, gdbm, db, lzma
+, python-setup-hook
+# For the Python package set
+, packageOverrides ? (self: super: {})
+}:
+
+assert zlibSupport -> zlib != null;
+
+let
+  version = "6.0.0";
+  pythonVersion = "3.5";
+  libPrefix = "pypy${pythonVersion}";
+  sitePackages = "site-packages";
+
+  pythonForPypy = python.withPackages (ppkgs: [ ppkgs.pycparser ]);
+
+in stdenv.mkDerivation rec {
+  name = "pypy3-${version}";
+  inherit version pythonVersion;
+
+  src = fetchurl {
+    url = "https://bitbucket.org/pypy/pypy/get/release-pypy${pythonVersion}-v${version}.tar.bz2";
+    sha256 = "0lwq8nn0r5yj01bwmkk5p7xvvrp4s550l8184mkmn74d3gphrlwg";
+  };
+
+  nativeBuildInputs = [ pkgconfig makeWrapper ];
+  buildInputs = [
+    bzip2 openssl pythonForPypy libffi ncurses expat sqlite tk tcl xlibsWrapper libX11 gdbm db lzma
+  ] ++ stdenv.lib.optional (stdenv ? cc && stdenv.cc.libc != null) stdenv.cc.libc
+    ++ stdenv.lib.optional zlibSupport zlib;
+
+  hardeningDisable = stdenv.lib.optional stdenv.isi686 "pic";
+
+  C_INCLUDE_PATH = stdenv.lib.makeSearchPathOutput "dev" "include" buildInputs;
+  LIBRARY_PATH = stdenv.lib.makeLibraryPath buildInputs;
+  LD_LIBRARY_PATH = stdenv.lib.makeLibraryPath (stdenv.lib.filter (x : x.outPath != stdenv.cc.libc.outPath or "") buildInputs);
+
+  patches = [
+    (substituteAll {
+      src = ./tk_tcl_paths.patch;
+      inherit tk tcl;
+      tk_dev = tk.dev;
+      tcl_dev = tcl;
+      tk_libprefix = tk.libPrefix;
+      tcl_libprefix = tcl.libPrefix;
+    })
+  ];
+
+  postPatch = ''
+    substituteInPlace "lib-python/3/tkinter/tix.py" --replace "os.environ.get('TIX_LIBRARY')" "os.environ.get('TIX_LIBRARY') or '${tix}/lib'"
+
+    # hint pypy to find nix ncurses
+    substituteInPlace pypy/module/_minimal_curses/fficurses.py \
+      --replace "/usr/include/ncurses/curses.h" "${ncurses.dev}/include/curses.h" \
+      --replace "ncurses/curses.h" "${ncurses.dev}/include/curses.h" \
+      --replace "ncurses/term.h" "${ncurses.dev}/include/term.h" \
+      --replace "libraries=['curses']" "libraries=['ncurses']"
+
+    sed -i "s@libraries=\['sqlite3'\]\$@libraries=['sqlite3'], include_dirs=['${sqlite.dev}/include'], library_dirs=['${sqlite.out}/lib']@" lib_pypy/_sqlite3_build.py
+  '';
+
+  buildPhase = ''
+    ${pythonForPypy.interpreter} rpython/bin/rpython \
+      --make-jobs="$NIX_BUILD_CORES" \
+      -Ojit \
+      --batch pypy/goal/targetpypystandalone.py
+  '';
+
+  setupHook = python-setup-hook sitePackages;
+
+  doCheck = true;
+  checkPhase = ''
+    export TERMINFO="${ncurses.out}/share/terminfo/";
+    export TERM="xterm";
+    export HOME="$TMPDIR";
+    # disable asyncio due to https://github.com/NixOS/nix/issues/1238
+    # disable os due to https://github.com/NixOS/nixpkgs/issues/10496
+    # disable pathlib due to https://bitbucket.org/pypy/pypy/pull-requests/594
+    # disable shutils because it assumes gid 0 exists
+    # disable socket because it has two actual network tests that fail
+    # disable tarfile because it assumes gid 0 exists
+    ${pythonForPypy.interpreter} ./pypy/test_all.py --pypy=./pypy3-c -k 'not ( test_asyncio or test_os or test_pathlib or test_shutil or test_socket or test_tarfile )' lib-python
+  '';
+
+  installPhase = ''
+    mkdir -p $out/{bin,include,lib,pypy3-c}
+
+    cp -R {include,lib_pypy,lib-python,pypy3-c} $out/pypy3-c
+    cp libpypy3-c.so $out/lib/
+    ln -s $out/pypy3-c/pypy3-c $out/bin/pypy3
+
+    # other packages expect to find stuff according to libPrefix
+    ln -s $out/pypy3-c/include $out/include/${libPrefix}
+    ln -s $out/pypy3-c/lib-python/3 $out/lib/${libPrefix}
+
+    # We must wrap the original, not the symlink.
+    # PyPy uses argv[0] to find its standard library, and while it knows
+    # how to follow symlinks, it doesn't know about wrappers. So, it
+    # will think the wrapper is the original. As long as the wrapper has
+    # the same path as the original, this is OK.
+    wrapProgram "$out/pypy3-c/pypy3-c" \
+      --set LD_LIBRARY_PATH "${LD_LIBRARY_PATH}:$out/lib" \
+      --set LIBRARY_PATH "${LIBRARY_PATH}:$out/lib"
+
+    # verify cffi modules
+    $out/bin/pypy3 -c "import tkinter;import sqlite3;import curses;import lzma"
+
+    # Python on Nix is not manylinux1 compatible. https://github.com/NixOS/nixpkgs/issues/18484
+    echo "manylinux1_compatible=False" >> $out/lib/${libPrefix}/_manylinux.py
+  '';
+
+  passthru = let
+    pythonPackages = callPackage ../../../../../top-level/python-packages.nix {python=self; overrides=packageOverrides;};
+  in rec {
+    inherit zlibSupport libPrefix sitePackages;
+    executable = "pypy3";
+    isPypy = true;
+    isPy3 = true;
+    isPy35 = true;
+    buildEnv = callPackage ../../wrapper.nix { python = self; inherit (pythonPackages) requiredPythonModules; };
+    interpreter = "${self}/bin/${executable}";
+    withPackages = import ../../with-packages.nix { inherit buildEnv pythonPackages;};
+    pkgs = pythonPackages;
+  };
+
+  enableParallelBuilding = true;  # almost no parallelization without STM
+
+  meta = with stdenv.lib; {
+    homepage = http://pypy.org/;
+    description = "Fast, compliant alternative implementation of the Python language (3.5.3)";
+    license = licenses.mit;
+    platforms = [ "i686-linux" "x86_64-linux" ];
+    maintainers = with maintainers; [ andersk ];
+  };
+}

pkgs/development/interpreters/python/pypy/3/tk_tcl_paths.patch

···
+--- pypy-pypy-84a2f3e6a7f8.org/lib_pypy/_tkinter/tklib_build.py	2017-10-03 11:49:20.000000000 +0100
++++ pypy-pypy-84a2f3e6a7f8/lib_pypy/_tkinter/tklib_build.py	2017-11-21 13:20:51.398607530 +0000
+@@ -24,11 +24,11 @@
+ else:
+     # On some Linux distributions, the tcl and tk libraries are
+     # stored in /usr/include, so we must check this case also
+-    libdirs = []
++    libdirs = ["@tcl@/lib", "@tk@/lib"]
+     found = False
+     for _ver in ['', '8.6', '8.5']:
+-        incdirs = ['/usr/include/tcl' + _ver]
+-        linklibs = ['tcl' + _ver, 'tk' + _ver]
++        incdirs = ['@tcl_dev@/include', '@tk_dev@/include']
++        linklibs = ['@tcl_libprefix@', '@tk_libprefix@']
+         if os.path.isdir(incdirs[0]):
+             found = True
+             break

pkgs/development/libraries/aften/default.nix

···
 		description = "An audio encoder which generates compressed audio streams based on ATSC A/52 specification";
 		homepage = "http://aften.sourceforge.net/";
 		license = stdenv.lib.licenses.lgpl2;
-		platforms = stdenv.lib.platforms.unix;
+		platforms = [ "i686-linux" "x86_64-linux" "x86_64-darwin" ];
 	};
 }

pkgs/development/libraries/allegro/5.nix

···
-{ stdenv, fetchFromGitHub, texinfo, libXext, xextproto, libX11, xproto
+{ stdenv, fetchFromGitHub, fetchpatch, texinfo, libXext, xextproto, libX11, xproto
 , libXpm, libXt, libXcursor, alsaLib, cmake, zlib, libpng, libvorbis
 , libXxf86dga, libXxf86misc, xf86dgaproto, xf86miscproto
 , xf86vidmodeproto, libXxf86vm, openal, libGLU_combined, kbproto, libjpeg, flac
···
     libpulseaudio libpthreadstubs
   ];
 
-  patchPhase = ''
+  patches = [
+   # fix compilation with mesa 18.2.5
+   (fetchpatch {
+     url = "https://github.com/liballeg/allegro5/commit/a40d30e21802ecf5c9382cf34af9b01bd3781e47.patch";
+     sha256 = "1f1xlj5y2vr6wzmcz04s8kxn8cfdwrg9kjlnvpz9dix1z3qjnd4m";
+   })
+  ];
+
+  postPatch = ''
     sed -e 's@/XInput2.h@/XI2.h@g' -i CMakeLists.txt "src/"*.c
   '';
 

pkgs/development/libraries/avahi/default.nix

···
 { fetchurl, stdenv, pkgconfig, libdaemon, dbus, perlPackages
 , expat, gettext, intltool, glib, libiconv
+, gtk3Support ? false, gtk3 ? null
 , qt4 ? null
 , qt4Support ? false
 , withLibdnssdCompat ? false }:
···
 
   buildInputs = [ libdaemon dbus glib expat libiconv ]
     ++ (with perlPackages; [ perl XMLParser ])
+    ++ (stdenv.lib.optional gtk3Support gtk3)
     ++ (stdenv.lib.optional qt4Support qt4);
 
   nativeBuildInputs = [ pkgconfig gettext intltool glib ];
 
   configureFlags =
     [ "--disable-qt3" "--disable-gdbm" "--disable-mono"
-      "--disable-gtk" "--disable-gtk3"
+      "--disable-gtk"
+      (stdenv.lib.enableFeature gtk3Support "gtk3")
       "--${if qt4Support then "enable" else "disable"}-qt4"
       "--disable-python" "--localstatedir=/var" "--with-distro=none"
       # A systemd unit is provided by the avahi-daemon NixOS module

pkgs/development/libraries/beignet/default.nix

···
     license = licenses.lgpl21Plus;
     maintainers = with maintainers; [ artuuge zimbatm ];
     platforms = platforms.linux;
+    # Requires libdrm_intel
+    badPlatforms = [ "aarch64-linux" ];
   };
 }

pkgs/development/libraries/boost/generic.nix

···
     description = "Collection of C++ libraries";
     license = stdenv.lib.licenses.boost;
 
-    platforms = (if versionOlder version "1.59" then remove "aarch64-linux" else id) (platforms.unix ++ platforms.windows);
+    platforms = (platforms.unix ++ platforms.windows);
+    badPlatforms = stdenv.lib.optional (versionOlder version "1.59") "aarch64-linux";
     maintainers = with maintainers; [ peti wkennington ];
   };
 

pkgs/development/libraries/bootil/default.nix

···
     license = stdenv.lib.licenses.free;
     maintainers = [ stdenv.lib.maintainers.abigailbuccaneer ];
     platforms = stdenv.lib.platforms.all;
+    # Build uses `-msse` and `-mfpmath=sse`
+    badPlatforms = [ "aarch64-linux" ];
   };
 
   src = fetchFromGitHub {

pkgs/development/libraries/dbus-sharp/default.nix

···
-{stdenv, fetchFromGitHub, pkgconfig, mono48, autoreconfHook }:
+{stdenv, fetchFromGitHub, pkgconfig, mono4, autoreconfHook }:
 
 stdenv.mkDerivation rec {
   name = "dbus-sharp-${version}";
···
 
   # Use msbuild when https://github.com/NixOS/nixpkgs/pull/43680 is merged
   # See: https://github.com/NixOS/nixpkgs/pull/46060
-  buildInputs = [ mono48 ];
+  buildInputs = [ mono4 ];
 
   dontStrip = true;
 

pkgs/development/libraries/fdk-aac/default.nix

···
 with stdenv.lib;
 stdenv.mkDerivation rec {
   name = "fdk-aac-${version}";
-  version = "0.1.6";
+  version = "2.0.0";
 
   src = fetchurl {
     url = "mirror://sourceforge/opencore-amr/fdk-aac/${name}.tar.gz";
-    sha256 = "1bfkpqba0v2jgxqwaf9xsrr63a089wckrir497lm6nbbmi11pdma";
+    sha256 = "0v6rbyw9f9lpfvcg3v1qyapga5hqfnb3wp3x5yaxpwcgjw7ydmpp";
   };
 
   configureFlags = [ ]

pkgs/development/libraries/freetds/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "freetds-${version}";
-  version = "1.00.104";
+  version = "1.00.109";
 
   src = fetchurl {
     url    = "http://www.freetds.org/files/stable/${name}.tar.bz2";
-    sha256 = "0mlg027mppv2348f4wwdpxpac9baqkdsg7xqx21kyx5dx5kmr71g";
+    sha256 = "0d00ixf78jzkyhccxjsaspz7yvlwk0xvrfcqfca4cwnwvnyb54ry";
   };
 
   buildInputs = [

pkgs/development/libraries/goffice/default.nix

···
-{ fetchurl, stdenv, pkgconfig, intltool, glib, gtk3
-, libgsf, libxml2, libxslt, cairo, pango, librsvg }:
+{ fetchurl, stdenv, pkgconfig, intltool, glib, gtk3, lasem
+, libgsf, libxml2, libxslt, cairo, pango, librsvg, gnome3 }:
 
 stdenv.mkDerivation rec {
-  name = "goffice-0.10.44";
+  pname = "goffice";
+  version = "0.10.44";
+
+  outputs = [ "out" "dev" "devdoc" ];
 
   src = fetchurl {
-    url = "mirror://gnome/sources/goffice/0.10/${name}.tar.xz";
+    url = "mirror://gnome/sources/${pname}/${stdenv.lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
     sha256 = "1fd7cm6j0g0mqgpqs4y22b4gd2ll4mcyvg4d0q22d5ndjapl4q3d";
   };
 
   nativeBuildInputs = [ pkgconfig intltool ];
 
-  propagatedBuildInputs = [ # ToDo lasem library for MathML, opt. introspection?
-    glib gtk3 libxml2 cairo pango libgsf
+  propagatedBuildInputs = [
+    glib gtk3 libxml2 cairo pango libgsf lasem
   ];
 
   buildInputs = [ libxslt librsvg ];
 
   enableParallelBuilding = true;
   doCheck = true;
+
+  passthru = {
+    updateScript = gnome3.updateScript {
+      packageName = pname;
+    };
+  };
 
   meta = {
     description = "A Glib/GTK+ set of document centric objects and utilities";

pkgs/development/libraries/goocanvasmm/default.nix

···
+{ stdenv, fetchurl, pkgconfig, goocanvas2, gtkmm3, gnome3 }:
+
+stdenv.mkDerivation rec {
+  pname = "goocanvasmm";
+  version = "1.90.11";
+
+  outputs = [ "out" "dev" ];
+
+  src = fetchurl {
+    url = "mirror://gnome/sources/${pname}/${stdenv.lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
+    sha256 = "0vpdfrj59nwzwj8bk4s0h05iyql62pxjzsxh72g3vry07s3i3zw0";
+  };
+  nativeBuildInputs = [ pkgconfig ];
+  propagatedBuildInputs = [ gtkmm3 goocanvas2 ];
+
+  enableParallelBuilding = true;
+
+  passthru = {
+    updateScript = gnome3.updateScript {
+      packageName = pname;
+    };
+  };
+
+  meta = with stdenv.lib; {
+    description = "C++ bindings for GooCanvas";
+    homepage = https://wiki.gnome.org/Projects/GooCanvas;
+    license = licenses.lgpl2;
+    maintainers = with maintainers; [ ];
+    platforms = platforms.unix;
+  };
+}

pkgs/development/libraries/gsl/gsl-1_16.nix

···
       extensive test suite.
     '';
     platforms = stdenv.lib.platforms.unix;
+    # Failing "eigen" tests on aarch64.
+    badPlatforms = [ "aarch64-linux" ];
   };
 }

pkgs/development/libraries/gtksourceviewmm/4.x.nix

···
+{ stdenv, fetchurl, pkgconfig, gtkmm3, glibmm, gtksourceview4, gnome3 }:
+
+stdenv.mkDerivation rec {
+  pname = "gtksourceviewmm";
+  version = "3.91.1";
+
+  src = fetchurl {
+    url = "mirror://gnome/sources/${pname}/${stdenv.lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
+    sha256 = "088p2ch1b4fvzl9416nw3waj0pqgp31cd5zj4lx5hzzrq2afgapy";
+  };
+
+  passthru = {
+    updateScript = gnome3.updateScript {
+      packageName = pname;
+      versionPolicy = "none";
+    };
+  };
+
+  nativeBuildInputs = [ pkgconfig ];
+  propagatedBuildInputs = [ glibmm gtkmm3 gtksourceview4 ];
+
+  meta = with stdenv.lib; {
+    platforms = platforms.linux;
+    homepage = https://developer.gnome.org/gtksourceviewmm/;
+    description = "C++ wrapper for gtksourceview";
+    license = licenses.lgpl2;
+    maintainers = gnome3.maintainers;
+  };
+}
+

pkgs/development/libraries/icu/63.nix

···
+{ stdenv, lib, fetchurl, fetchpatch, fixDarwinDylibNames, nativeBuildRoot }:
+
+import ./base.nix {
+  version = "63.1";
+  sha256 = "17fbk0lm2clsxbmjzvyp245ayx0n4chji3ky1f3fbz2ljjv91i05";
+  patches = [
+    # https://bugzilla.mozilla.org/show_bug.cgi?id=1499398
+    (fetchpatch {
+      url = https://github.com/unicode-org/icu/commit/8baff8f03e07d8e02304d0c888d0bb21ad2eeb01.patch;
+      sha256 = "1awfa98ljcf95a85cssahw6bvdnpbq5brf1kgspy14w4mlmhd0jb";
+    })
+  ];
+  patchFlags = [ "-p3" ];
+} { inherit stdenv lib fetchurl fixDarwinDylibNames nativeBuildRoot; }

pkgs/development/libraries/icu/base.nix

···
 { version, sha256, patches ? [], patchFlags ? "" }:
-{ stdenv, fetchurl, fixDarwinDylibNames
+{ stdenv, lib, fetchurl, fixDarwinDylibNames
   # Cross-compiled icu4c requires a build-root of a native compile
 , buildRootOnly ? false, nativeBuildRoot
 }:
···
     '';
 
     # https://sourceware.org/glibc/wiki/Release/2.26#Removal_of_.27xlocale.h.27
-    postPatch = if (stdenv.hostPlatform.libc == "glibc" || stdenv.hostPlatform.libc == "musl")
+    postPatch = if (stdenv.hostPlatform.libc == "glibc" || stdenv.hostPlatform.libc == "musl") && lib.versionOlder version "62.1"
       then "substituteInPlace i18n/digitlst.cpp --replace '<xlocale.h>' '<locale.h>'"
       else null; # won't find locale_t on darwin
 

pkgs/development/libraries/lasem/default.nix

···
+{ fetchurl, stdenv, pkgconfig, intltool, gobject-introspection, glib, gdk_pixbuf
+, libxml2, cairo, pango, gnome3 }:
+
+stdenv.mkDerivation rec {
+  pname = "lasem";
+  version = "0.4.3";
+
+  outputs = [ "bin" "out" "dev" "man" "doc" "devdoc" ];
+
+  src = fetchurl {
+    url = "mirror://gnome/sources/${pname}/${stdenv.lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
+    sha256 = "13ym5pm2y3wk5hh9zb2535i3lnhnzyzs0na1knxwgvwxazwm1ng7";
+  };
+
+  nativeBuildInputs = [ pkgconfig intltool gobject-introspection ];
+
+  propagatedBuildInputs = [
+    glib gdk_pixbuf libxml2 cairo pango
+  ];
+
+  enableParallelBuilding = true;
+  doCheck = true;
+
+  passthru = {
+    updateScript = gnome3.updateScript {
+      packageName = pname;
+    };
+  };
+
+  meta = {
+    description = "SVG and MathML rendering library";
+
+    homepage = https://wiki.gnome.org/Projects/Lasem;
+    license = stdenv.lib.licenses.gpl2Plus;
+
+    platforms = stdenv.lib.platforms.unix;
+  };
+}

pkgs/development/libraries/libcollectdclient/default.nix

···
   name = "libcollectdclient-${collectd.version}";
   buildInputs = [ ];
 
-  NIX_CFLAGS_COMPILE = oldAttrs.NIX_CFLAGS_COMPILE ++ [
-    "-Wno-error=unused-function"
-  ];
-
-  configureFlags = oldAttrs.configureFlags ++ [
+  configureFlags = (oldAttrs.configureFlags or []) ++ [
     "--disable-daemon"
     "--disable-all-plugins"
   ];

pkgs/development/libraries/libepc/default.nix

···
+{ stdenv, fetchurl, pkgconfig, intltool, gtk-doc, glib, avahi, gnutls, libuuid, libsoup, gtk3, gnome3 }:
+
+let
+  avahiWithGtk = avahi.override { gtk3Support = true; };
+in stdenv.mkDerivation rec {
+  pname = "libepc";
+  version = "0.4.6";
+
+  outputs = [ "out" "dev" "devdoc" ];
+
+  src = fetchurl {
+    url = "mirror://gnome/sources/${pname}/${stdenv.lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
+    sha256 = "1s3svb2slqjsrqfv50c2ymnqcijcxb5gnx6bfibwh9l5ga290n91";
+  };
+
+  nativeBuildInputs = [
+    pkgconfig
+    intltool
+    gtk-doc
+  ];
+  buildInputs = [
+    glib
+    libuuid
+    gtk3
+  ];
+  propagatedBuildInputs = [
+    avahiWithGtk
+    gnutls
+    libsoup
+  ];
+
+  enableParallelBuilding = true;
+
+  passthru = {
+    updateScript = gnome3.updateScript {
+      packageName = pname;
+    };
+  };
+
+  meta = with stdenv.lib; {
+    description = "Easy Publish and Consume Library";
+    homepage = https://wiki.gnome.org/Projects/libepc;
+    license = licenses.lgpl21Plus;
+    maintainers = gnome3.maintainers;
+    platforms = platforms.linux;
+  };
+}

pkgs/development/libraries/libgda/default.nix

···
-{ stdenv, fetchurl, pkgconfig, intltool, itstool, libxml2, gtk3, openssl, gnome3, vala
+{ stdenv, fetchurl, pkgconfig, intltool, itstool, libxml2, gtk3, openssl, gnome3, gobject-introspection, vala
 , overrideCC, gcc6
 , mysqlSupport ? false, mysql ? null
 , postgresSupport ? false, postgresql ? null
···
 
   hardeningDisable = [ "format" ];
 
-  nativeBuildInputs = [ pkgconfig intltool itstool libxml2 vala ];
+  nativeBuildInputs = [ pkgconfig intltool itstool libxml2 gobject-introspection vala ];
   buildInputs = with stdenv.lib; [ gtk3 openssl gnome3.libgee ]
     ++ optional (mysqlSupport) mysql.connector-c
     ++ optional (postgresSupport) postgresql;

pkgs/development/libraries/libgdamm/default.nix

···
+{ stdenv, fetchurl, pkgconfig, glibmm, libgda, libxml2, gnome3
+, mysqlSupport ? false, mysql ? null
+, postgresSupport ? false, postgresql ? null }:
+
+let
+  gda = libgda.override {
+    inherit mysqlSupport postgresSupport;
+  };
+in stdenv.mkDerivation rec {
+  pname = "libgdamm";
+  version = "4.99.11";
+
+  outputs = [ "out" "dev" ];
+
+  src = fetchurl {
+    url = "mirror://gnome/sources/${pname}/${stdenv.lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
+    sha256 = "1fyh15b3f8hmwbswalxk1g4l04yvvybksn5nm7gznn5jl5q010p9";
+  };
+
+  nativeBuildInputs = [ pkgconfig ];
+  buildInputs = [ glibmm libxml2 ];
+  propagatedBuildInputs = [ gda ];
+
+  enableParallelBuilding = true;
+
+  passthru = {
+    updateScript = gnome3.updateScript {
+      packageName = pname;
+    };
+  };
+
+  meta = with stdenv.lib; {
+    description = "C++ bindings for libgda";
+    homepage = http://www.gnome-db.org/;
+    license = licenses.lgpl21Plus;
+    maintainers = gnome3.maintainers;
+    platforms = platforms.linux;
+  };
+}

pkgs/development/libraries/libgdiplus/default.nix

···
-{ stdenv, fetchurl, pkgconfig, glib, cairo, Carbon, fontconfig
+{ stdenv, fetchFromGitHub, pkgconfig, glib, cairo, Carbon, fontconfig
 , libtiff, giflib, libjpeg, libpng
-, libXrender, libexif }:
+, libXrender, libexif, autoreconfHook, fetchpatch }:
 
 stdenv.mkDerivation rec {
-  name = "libgdiplus-2.10.9";
+  name = "libgdiplus-5.6";
 
-  src = fetchurl {
-    url = "https://download.mono-project.com/sources/libgdiplus/${name}.tar.bz2";
-    sha256 = "0klnbly2q0yx5p0l5z8da9lhqsjj9xqj06kdw2v7rnms4z1vdpkd";
+  src = fetchFromGitHub {
+    owner = "mono";
+    repo = "libgdiplus";
+    rev = "5.6";
+    sha256 = "11xr84kng74j3pd8sx74q80a71k6dw0a502qgibcxlyqh666lfb7";
   };
 
   NIX_LDFLAGS = "-lgif";
 
-  patches =
-    [ (fetchurl {
-        url = "https://raw.github.com/MagicGroup/MagicSpecLib/master/libgdiplus/libgdiplus-2.10.1-libpng15.patch";
-        sha256 = "130r0jm065pjvbz5dkx96w37vj1wqc8fakmi2znribs14g0bl65f";
-      })
-      ./giflib.patch
-    ];
-
-  patchFlags = "-p0";
+  patches = [ # Series of patches cherry-picked from master, all fixes various sigsegv (or required by other patch)
+    (fetchpatch {
+          url = "https://github.com/mono/libgdiplus/commit/d33a2580a94701ff33abe28c22881d6173be57d0.patch";
+          sha256 = "0rr54jylscn4icqjprqhwrncyr92r0d7kmfrrq3myskplpqv1c11";
+    })
+    (fetchpatch {
+          url ="https://github.com/mono/libgdiplus/commit/aa6aa53906935572f52f519fe4ab9ebedc051d08.patch";
+          sha256 = "1wg0avm8qv5cb4vk80baflfzszm6q7ydhn89c3h6kq68hg6zsf1f";
+    })
+    (fetchpatch {
+          url = "https://github.com/mono/libgdiplus/commit/81e45a1d5a3ac3cf035bcc3fabb2859818b6cc04.patch";
+          sha256 = "07wmc88cd1lqifs5x6npryni65jyy9gi8lgr2i1lb7v0fhvlyswg";
+    })
+  ];
 
   hardeningDisable = [ "format" ];
 
+  nativeBuildInputs = [ autoreconfHook pkgconfig ];
+
   buildInputs =
-    [ pkgconfig glib cairo fontconfig libtiff giflib
+    [ glib cairo fontconfig libtiff giflib
       libjpeg libpng libXrender libexif
     ]
     ++ stdenv.lib.optional stdenv.isDarwin Carbon;
 
   postInstall = stdenv.lib.optionalString stdenv.isDarwin ''
     ln -s $out/lib/libgdiplus.0.dylib $out/lib/libgdiplus.so
+  '';
+
+  checkPhase = ''
+    make check -w
   '';
 
   meta = with stdenv.lib; {

pkgs/development/libraries/libgdiplus/giflib.patch

···
-diff -Naur libgdiplus-2.10.9-orig/src/gifcodec.c libgdiplus-2.10.9/src/gifcodec.c
---- src/gifcodec.c
-+++ src/gifcodec.c
-@@ -39,8 +39,10 @@
- 
- #include "gifcodec.h"
- 
-+#if GIFLIB_MAJOR < 5
- /* giflib declares this incorrectly as EgifOpen */
- extern GifFileType *EGifOpen(void *userData, OutputFunc writeFunc);
-+#endif
- 
- /* Data structure used for callback */
- typedef struct
-@@ -105,7 +107,7 @@
- */
- 
- static int
--AddExtensionBlockMono(SavedImage *New, int Len, BYTE ExtData[])
-+AddExtensionBlockMono(SavedImage *New, int Len, int func, BYTE ExtData[])
- {
- 	ExtensionBlock	*ep;
- 
-@@ -129,7 +131,7 @@
- 
- 	if (ExtData) {
- 		memcpy(ep->Bytes, ExtData, Len);
--		ep->Function = New->Function;
-+		ep->Function = func;
- 	}
- 
- 	return (GIF_OK);
-@@ -232,20 +234,20 @@
- 			}
- 
- 			case EXTENSION_RECORD_TYPE: {
--				if (DGifGetExtension(GifFile, &temp_save.Function, &ExtData) == GIF_ERROR) {
-+				int func;
-+				if (DGifGetExtension(GifFile, &func, &ExtData) == GIF_ERROR) {
- 					return (GIF_ERROR);
- 				}
- 
- 				while (ExtData != NULL) {
- 					/* Create an extension block with our data */
--					if (AddExtensionBlockMono(&temp_save, ExtData[0], &ExtData[1]) == GIF_ERROR) {
-+					if (AddExtensionBlockMono(&temp_save, func, ExtData[0], &ExtData[1]) == GIF_ERROR) {
- 						return (GIF_ERROR);
- 					}
- 
- 					if (DGifGetExtensionNext(GifFile, &ExtData) == GIF_ERROR) {
- 						return (GIF_ERROR);
- 					}
--					temp_save.Function = 0;
- 				}
- 				break;
- 			}
-@@ -303,12 +305,19 @@
- 	result = NULL;
- 	loop_counter = FALSE;
- 
-+#if GIFLIB_MAJOR < 5
- 	if (from_file) {
- 		gif = DGifOpen(stream, &gdip_gif_fileinputfunc);
- 	} else {
- 		gif = DGifOpen (stream, &gdip_gif_inputfunc);
- 	}
--	
-+#else
-+	if (from_file)
-+		gif = DGifOpen(stream, &gdip_gif_fileinputfunc, NULL);
-+	else
-+		gif = DGifOpen(stream, &gdip_gif_inputfunc, NULL);
-+#endif
-+
- 	if (gif == NULL) {
- 		goto error;
- 	}
-@@ -581,7 +590,7 @@
- 	}
- 
- 	FreeExtensionMono(&global_extensions);
--	DGifCloseFile (gif);
-+	DGifCloseFile (gif, NULL);
- 
- 	*image = result;
- 	return Ok;
-@@ -597,7 +606,7 @@
- 
- 	if (gif != NULL) {
- 		FreeExtensionMono (&global_extensions);
--		DGifCloseFile (gif);
-+		DGifCloseFile (gif, NULL);
- 	}
- 
- 	*image = NULL;
-@@ -660,11 +669,22 @@
- 		return InvalidParameter;
- 	}
- 
-+#if GIFLIB_MAJOR < 5
- 	if (from_file) {
- 		fp = EGifOpenFileName (stream, 0);
- 	} else {
- 		fp = EGifOpen (stream, gdip_gif_outputfunc);
- 	}
-+#else
-+	if (from_file)
-+		fp = EGifOpenFileName (stream, 0, NULL);
-+	else
-+		fp = EGifOpen (stream, gdip_gif_outputfunc, NULL);
-+#define MakeMapObject  GifMakeMapObject
-+#define FreeMapObject  GifFreeMapObject
-+#define QuantizeBuffer GifQuantizeBuffer
-+#define BitSize        GifBitSize
-+#endif
- 		
- 	if (!fp) {
- 		return FileNotFound;
-@@ -848,8 +868,15 @@
- 						Buffer[0] = 1;
- 						Buffer[1] = ptr[0];
- 						Buffer[2] = ptr[1];
-+#if GIFLIB_MAJOR < 5
- 						EGifPutExtensionFirst(fp, APPLICATION_EXT_FUNC_CODE, 11, "NETSCAPE2.0");
- 						EGifPutExtensionLast(fp, APPLICATION_EXT_FUNC_CODE, 3, Buffer);
-+#else
-+						EGifPutExtensionLeader(fp, APPLICATION_EXT_FUNC_CODE);
-+						EGifPutExtensionBlock(fp, 11, "NETSCAPE2.0");
-+						EGifPutExtensionBlock(fp, 3, Buffer);
-+						EGifPutExtensionTrailer(fp);
-+#endif
- 					}
- 				}
- 
-@@ -923,7 +950,7 @@
- 		}
- 	}
- 
--	EGifCloseFile (fp);	
-+	EGifCloseFile (fp, NULL);	
- 	
- 	return Ok;
-

pkgs/development/libraries/libgrss/default.nix

···
   passthru = {
     updateScript = gnome3.updateScript {
       packageName = pname;
+      versionPolicy = "none";
     };
   };
 

pkgs/development/libraries/librealsense/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "librealsense-${version}";
-  version = "2.16.4";
+  version = "2.17.0";
 
   src = fetchFromGitHub {
     owner = "IntelRealSense";
     repo = "librealsense";
     rev = "v${version}";
-    sha256 = "0664lsdw9a3s3apqiv9kkzfnz86ai9wdc8y00qyxrmxq9lpjsq11";
+    sha256 = "1ac580yhxmvxpdvlzdzpcdffysr6z3dl8dykndnq5758alkyspd7";
   };
 
   buildInputs = [

pkgs/development/libraries/librime/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "librime-${version}";
-  version = "1.3.1";
+  version = "1.3.2";
 
   src = fetchFromGitHub {
     owner = "rime";
     repo = "librime";
     rev = "${version}";
-    sha256 = "1y0h3nnz97smx9z8h5fzk4c27mvrwv8kajxffqc43bhyvxvb2jd6";
+    sha256 = "06q10cv7a3i6d8l3sq79nasw3p1njvmjgh4jq2hqw9abcx351m1r";
   };
 
   nativeBuildInputs = [ cmake ];

pkgs/development/libraries/mailcore2/default.nix

···
 stdenv.mkDerivation rec {
   name = "mailcore2-${version}";
 
-  version = "0.6.2";
+  version = "0.6.3";
 
   src = fetchFromGitHub {
     owner  = "MailCore";
     repo   = "mailcore2";
     rev    = version;
-    sha256 = "1d0wmnkk9vnjqc28i79z3fwaaycdbprfspagik4mzdkgval5r5pm";
+    sha256 = "0yxynvfmifpw9hdhv499a813hb2ynan74r353lhcdajkkm7w8br5";
   };
 
   nativeBuildInputs = [ pkgconfig ];

pkgs/development/libraries/mm-common/default.nix

···
+{ stdenv, fetchurl, gnome3 }:
+
+stdenv.mkDerivation rec {
+  pname = "mm-common";
+  version = "0.9.12";
+
+  src = fetchurl {
+    url = "mirror://gnome/sources/${pname}/${stdenv.lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
+    sha256 = "02vwgv404b56wxy0gnm9xq9fvzgn9dhfqcy2hhl78ljv3v7drzyf";
+  };
+
+  passthru = {
+    updateScript = gnome3.updateScript {
+      packageName = pname;
+      versionPolicy = "none";
+    };
+  };
+
+  meta = with stdenv.lib; {
+    description = "Common build files of GLib/GTK+ C++ bindings";
+    longDescription = ''
+      The mm-common module provides the build infrastructure and utilities
+      shared among the GNOME C++ binding libraries. It is only a required
+      dependency for building the C++ bindings from the gnome.org version
+      control repository. An installation of mm-common is not required for
+      building tarball releases, unless configured to use maintainer-mode.
+    '';
+    homepage = http://www.gtkmm.org;
+    license = licenses.gpl2Plus;
+    maintainers = gnome3.maintainers;
+    platforms = platforms.linux;
+  };
+}

pkgs/development/libraries/mono-addins/default.nix

···
-{ stdenv, fetchFromGitHub, autoreconfHook, pkgconfig, mono48, gtk-sharp-2_0 }:
+{ stdenv, fetchFromGitHub, autoreconfHook, pkgconfig, mono4, gtk-sharp-2_0 }:
 
 stdenv.mkDerivation rec {
   name = "mono-addins-${version}";
···
   nativeBuildInputs = [ pkgconfig autoreconfHook ];
 
   # Use msbuild when https://github.com/NixOS/nixpkgs/pull/43680 is merged
-  buildInputs = [ mono48 gtk-sharp-2_0 ];
+  buildInputs = [ mono4 gtk-sharp-2_0 ];
 
   dontStrip = true;
 

pkgs/development/libraries/mpich/default.nix

···
   doCheck = true;
 
   preFixup = ''
+    # Ensure the default compilers are the ones mpich was built with
+    sed -i 's:CC="gcc":CC=${stdenv.cc}/bin/gcc:' $out/bin/mpicc
+    sed -i 's:CXX="g++":CXX=${stdenv.cc}/bin/g++:' $out/bin/mpicxx
+    sed -i 's:FC="gfortran":FC=${gfortran}/bin/gfortran:' $out/bin/mpifort
+  ''
+  + stdenv.lib.optionalString (!stdenv.isDarwin) ''
     # /tmp/nix-build... ends up in the RPATH, fix it manually
     for entry in $out/bin/mpichversion $out/bin/mpivars; do
       echo "fix rpath: $entry"
       patchelf --set-rpath "$out/lib" $entry
     done
-
-    # Ensure the default compilers are the ones mpich was built with
-    sed -i 's:CC="gcc":CC=${stdenv.cc}/bin/gcc:' $out/bin/mpicc
-    sed -i 's:CXX="g++":CXX=${stdenv.cc}/bin/g++:' $out/bin/mpicxx
-    sed -i 's:FC="gfortran":FC=${gfortran}/bin/gfortran:' $out/bin/mpifort
-  '';
+    '';
 
   meta = with stdenv.lib; {
     description = "Implementation of the Message Passing Interface (MPI) standard";
···
       fullName = "MPICH license (permissive)";
     };
     maintainers = [ maintainers.markuskowa ];
-    platforms = platforms.linux;
+    platforms = platforms.linux ++ platforms.darwin;
   };
 }

pkgs/development/libraries/nlohmann_json/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "nlohmann_json-${version}";
-  version = "3.4.0";
+  version = "3.5.0";
 
   src = fetchFromGitHub {
     owner = "nlohmann";
     repo = "json";
     rev = "v${version}";
-    sha256 = "1140gz5za7yvfcphdgxaq1dm4b1vxy1m8d1w0s0smv4vvdvl26ym";
+    sha256 = "1jq522d48bvfrxr4f6jnijwx2dwqfb8w9k636j4kxlg1hka27lji";
   };
 
   nativeBuildInputs = [ cmake ];

pkgs/development/libraries/openbabel/default.nix

···
-{stdenv, fetchurl, cmake, zlib, libxml2, eigen, python, cairo, pcre, pkgconfig }:
+{stdenv, fetchurl, fetchpatch, cmake, zlib, libxml2, eigen, python, cairo, pcre, pkgconfig }:
 
 stdenv.mkDerivation rec {
   name = "openbabel-${version}";
···
     url = "https://github.com/openbabel/openbabel/archive/openbabel-${stdenv.lib.replaceStrings ["."] ["-"] version}.tar.gz";
     sha256 = "0xm7y859ivq2cp0q08mwshfxm0jq31xkyr4x8s0j6l7khf57yk2r";
   };
+
+  patches = [
+    # ARM / AArch64 fixes.
+    (fetchpatch {
+      url = https://github.com/openbabel/openbabel/commit/ee11c98a655296550710db1207b294f00e168216.patch;
+      sha256 = "0wjqjrkr4pfirzzicdvlyr591vppydk572ix28jd2sagnfnf566g";
+    })
+  ];
 
   # TODO : perl & python bindings;
   # TODO : wxGTK: I have no time to compile

pkgs/development/libraries/opencv/3.x.nix

···
 }:
 
 let
-  version = "3.4.4";
+  version = "3.4.5";
 
   src = fetchFromGitHub {
     owner  = "opencv";
     repo   = "opencv";
     rev    = version;
-    sha256 = "1xzbv0922r2zq4fgpkc1ldyq3kxp4c6x6dizydbspka18jrrxqlr";
+    sha256 = "0hz9316ys2qi0lx9dcbsk3mkn8cn08q12hc96p6zz2d4is6d5wsc";
   };
 
   contribSrc = fetchFromGitHub {
     owner  = "opencv";
     repo   = "opencv_contrib";
     rev    = version;
-    sha256 = "0ylsljkmgfj5vam05cv0z3qwkqwjwz5fs5f5yif3pwvb99lxlbib";
+    sha256 = "1fw7qwgibiznqal2dg4alkw8hrrrpjc0jaicf2406604rjm2lx6h";
   };
 
   # Contrib must be built in order to enable Tesseract support:
···
   postUnpack = lib.optionalString buildContrib ''
     cp --no-preserve=mode -r "${contribSrc}/modules" "$NIX_BUILD_TOP/opencv_contrib"
   '';
-
-  patches =
-    # https://github.com/opencv/opencv/pull/13254
-    lib.optional enablePython (fetchpatch {
-      url = https://github.com/opencv/opencv/commit/ad35b79e3f98b4ce30481e0299cca550ed77aef0.patch;
-      sha256 = "0rkvg6wm5fyncszfpd83wa4lvsb8srvk21r1jcld758i4f334sws";
-    });
 
   # This prevents cmake from using libraries in impure paths (which
   # causes build failure on non NixOS)

pkgs/development/libraries/opencv/4.x.nix

···
 }:
 
 let
-  version = "4.0.0";
+  version = "4.0.1";
 
   src = fetchFromGitHub {
     owner  = "opencv";
     repo   = "opencv";
     rev    = version;
-    sha256 = "1r2hszm4044dfx65wv69rcs419jjd7bqllhnpcwk3n28f5ahln50";
+    sha256 = "1f0n2a57sn47w55vaxlwhr3g6xgchvr3gxicxbkyzai3pvj55k48";
   };
 
   contribSrc = fetchFromGitHub {
     owner  = "opencv";
     repo   = "opencv_contrib";
-    rev    = version;
+    # TODO: set to `version` when opencv_contrib-4.0.1 is released;
+    # See: http://answers.opencv.org/question/205793/will-there-be-a-opencv_contrib-401-release-now-that-opencv-401-is-out/
+    rev    = "4.0.0";
     sha256 = "1g4pzw7hv1v9jp1nrqjxqwpi1byl3mxkj6w6ibq6ydsn0138p66z";
   };
 
···
       sha256 = "102mq1qgmla40hhj8mda70inhakdazm9agyah98kq9931scvf0c9";
       stripLen = 2;
       extraPrefix = "opencv_contrib/";
-    }) ++
-    # https://github.com/opencv/opencv/pull/13254
-    lib.optional enablePython (fetchpatch {
-      url = https://github.com/opencv/opencv/commit/ad35b79e3f98b4ce30481e0299cca550ed77aef0.patch;
-      sha256 = "0rkvg6wm5fyncszfpd83wa4lvsb8srvk21r1jcld758i4f334sws";
     });
 
   # This prevents cmake from using libraries in impure paths (which

pkgs/development/libraries/qmlbox2d/default.nix

···
 {stdenv, qtdeclarative, fetchFromGitHub, qmake }:
 stdenv.mkDerivation rec {
-  name = "qml-box2d-2018-03-16";
+  name = "qml-box2d-2018-04-06";
   src = fetchFromGitHub {
     owner = "qml-box2d";
     repo = "qml-box2d";
-    sha256 = "1fbsvv28b4r0szcv8bk5gxpf8v534jp2axyfp438384sy757wsq2";
-    rev = "21e57f1";
+    sha256 = "0gb8limy6ck23z3k0k2j7c4c4s95p40f6lbzk4szq7fjnnw22kb7";
+    rev = "b7212d5640701f93f0cd88fbd3a32c619030ae62";
   };
 
   enableParallelBuilding = true;

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

···
 { stdenvNoCC, writeText, fetchurl, rpmextract, undmg }:
 /*
-  Some (but not all) mkl functions require openmp, but Intel does not add these
-  to SO_NEEDED and instructs users to put openmp on their LD_LIBRARY_PATH. If
-  you are using mkl and your library/application is using some of the functions
-  that require openmp, add a setupHook like this to your package:
-
-  setupHook = writeText "setup-hook.sh" ''
-    addOpenmp() {
-        addToSearchPath LD_LIBRARY_PATH ${openmp}/lib
-    }
-    addEnvHooks "$targetOffset" addOpenmp
-  '';
-
-  We do not add the setup hook here, because avoiding it allows this large
-  package to be a fixed-output derivation with better cache efficiency.
- */
-
+  For details on using mkl as a blas provider for python packages such as numpy,
+  numexpr, scipy, etc., see the Python section of the NixPkgs manual.
+*/
 stdenvNoCC.mkDerivation rec {
   name = "mkl-${version}";
   version = "${date}.${rel}";
···
   '' else ''
     rpmextract rpm/intel-mkl-common-c-${date}-${rel}-${date}-${rel}.noarch.rpm
     rpmextract rpm/intel-mkl-core-rt-${date}-${rel}-${date}-${rel}.x86_64.rpm
+    rpmextract rpm/intel-openmp-19.0.0-${rel}-19.0.0-${rel}.x86_64.rpm
   '';
 
   installPhase = if stdenvNoCC.isDarwin then ''
       mkdir -p $out/lib
+
       cp -r compilers_and_libraries_${version}/mac/mkl/include $out/
+
+      cp -r compilers_and_libraries_${version}/licensing/mkl/en/license.txt $out/lib/
+      cp -r compilers_and_libraries_${version}/mac/compiler/lib/* $out/lib/
       cp -r compilers_and_libraries_${version}/mac/mkl/lib/* $out/lib/
-      cp -r compilers_and_libraries_${version}/licensing/mkl/en/license.txt $out/lib/
   '' else ''
       mkdir -p $out/lib
+
       cp -r opt/intel/compilers_and_libraries_${version}/linux/mkl/include $out/
+
+      cp -r opt/intel/compilers_and_libraries_${version}/linux/compiler/lib/intel64_lin/* $out/lib/
       cp -r opt/intel/compilers_and_libraries_${version}/linux/mkl/lib/intel64_lin/* $out/lib/
       cp license.txt $out/lib/
   '';
···
   outputHashAlgo = "sha256";
   outputHashMode = "recursive";
   outputHash = if stdenvNoCC.isDarwin
-    then "1224dln7n8px1rk8biiggf77wjhxh8mzw0hd8zlyjm8i6j8w7i12"
-    else "0d8ai0wi8drp071acqkm1wv6vyg12010y843y56zzi1pql81xqvx";
+    then "0000000000000000000000000000000000000000000000000000"
+    else "1amagcaan0hk3x9v7gg03gkw02n066v4kmjb32yyzsy5rfrivb1a";
 
   meta = with stdenvNoCC.lib; {
     description = "Intel Math Kernel Library";
···
       threading models.
     '';
     homepage = https://software.intel.com/en-us/mkl;
-    license = [ licenses.issl licenses.unfreeRedistributable ];
+    license = licenses.issl;
     platforms = [ "x86_64-linux" "x86_64-darwin" ];
     maintainers = [ maintainers.bhipple ];
   };

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

···
 
   inherit blas64;
 
+  patches = [
+    # Fixes build on x86_64-darwin. See:
+    # https://github.com/xianyi/OpenBLAS/issues/1926
+    (fetchpatch {
+      url = https://github.com/xianyi/OpenBLAS/commit/701ea88347461e4c5d896765438dc870281b3834.patch;
+      sha256 = "18rcfgkjsijl9d2510jn961wqvz7zdlz2fgy1yjmax29kvv8fqd9";
+    })
+  ];
+
   # Some hardening features are disabled due to sporadic failures in
   # OpenBLAS-based programs. The problem may not be with OpenBLAS itself, but
   # with how these flags interact with hardening measures used downstream.
···
       "NO_STATIC=1"
     ] ++ stdenv.lib.optional (stdenv.hostPlatform.libc == "musl") "NO_AFFINITY=1"
     ++ mapAttrsToList (var: val: var + "=" + val) config;
-
-    patches = [];
 
   doCheck = true;
   checkTarget = "tests";

pkgs/development/libraries/wlroots/default.nix

···
 , wayland, libGL, wayland-protocols, libinput, libxkbcommon, pixman
 , xcbutilwm, libX11, libcap, xcbutilimage, xcbutilerrors, mesa_noglu
 , libpng, ffmpeg_4
-, python3Packages # TODO: Temporary
 }:
 
 let
   pname = "wlroots";
   version = "0.2";
-  meson480 = meson.overrideAttrs (oldAttrs: rec {
-    name = pname + "-" + version;
-    pname = "meson";
-    version = "0.48.0";
-
-    src = python3Packages.fetchPypi {
-      inherit pname version;
-      sha256 = "0qawsm6px1vca3babnqwn0hmkzsxy4w0gi345apd2qk3v0cv7ipc";
-    };
-    # Remove gir-fallback-path.patch and
-    # a87496addd9160300837aa50193f4798c6f1d251.patch (already in 0.48.0):
-    patches = builtins.filter
-      (str: !(stdenv.lib.hasSuffix "gir-fallback-path.patch" str
-              || stdenv.lib.hasSuffix "a87496addd9160300837aa50193f4798c6f1d251.patch" str))
-      oldAttrs.patches;
-  });
 in stdenv.mkDerivation rec {
   name = "${pname}-${version}";
 
···
   # programs (in examples) AND rootston
   outputs = [ "out" "bin" "examples" ];
 
-  nativeBuildInputs = [ meson480 ninja pkgconfig ];
+  nativeBuildInputs = [ meson ninja pkgconfig ];
 
   buildInputs = [
     wayland libGL wayland-protocols libinput libxkbcommon pixman

pkgs/development/libraries/wt/default.nix

···
   };
 
   wt4 = generic {
-    version = "4.0.4";
-    sha256 = "17kq9fxc0xqx7q7kyryiph3mg0d3hnd3jw0rl55zvzfsdd71220w";
+    version = "4.0.5";
+    sha256 = "1gn8f30mjmn9aaxdazk49wijz37nglfww15ydrjiyhl6v5xhsjdv";
   };
 }

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

···
 
 stdenv.mkDerivation rec {
   name = "ocaml-${pname}-${version}";
-  version = "1.0.2";
+  version = "1.0.3";
 
   src = fetchurl {
     url = "http://erratique.ch/software/${pname}/releases/${pname}-${version}.tbz";
-    sha256 = "18jqphjiifljlh9jg8zpl6310p3iwyaqphdkmf89acyaix0s4kj1";
+    sha256 = "0g3w4hvc1cx9x2yp5aqn6m2rl8lf9x1dn754hfq8m1sc1102lxna";
   };
 
   nativeBuildInputs = [ ocamlbuild topkg ];

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

···
+{ lib, buildDunePackage, ocaml, csv, ocaml_lwt }:
+
+if !lib.versionAtLeast ocaml.version "4.02"
+then throw "csv-lwt is not available for OCaml ${ocaml.version}"
+else
+
+buildDunePackage {
+  pname = "csv-lwt";
+  inherit (csv) src version meta;
+
+  propagatedBuildInputs = [ csv ocaml_lwt ];
+
+  doCheck = lib.versionAtLeast ocaml.version "4.03";
+}

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

···
 
 stdenv.mkDerivation rec {
   name = "ocaml-curses-${version}";
-  version = "1.0.3";
+  version = "1.0.4";
 
   src = fetchurl {
     url = "http://ocaml.phauna.org/distfiles/ocaml-curses-${version}.ogunden1.tar.gz";
-    sha256 = "0fxya4blx4zcp9hy8gxxm2z7aas7hfvwnjdlj9pmh0s5gijpwsll";
+    sha256 = "08wq1r93lincdfzlriyc5nl2p4q7ca4h6ygzgp1nhkgd93pgk9v2";
   };
 
   propagatedBuildInputs = [ ncurses ];
···
 
   meta = with stdenv.lib; {
     description = "OCaml Bindings to curses/ncurses";
-    homepage = https://opam.ocaml.org/packages/curses/curses.1.0.3/;
+    homepage = https://opam.ocaml.org/packages/curses/curses.1.0.4/;
     license = licenses.gpl2;
     maintainers = [ maintainers.volth ];
     platforms = ocaml.meta.platforms or [];

pkgs/development/pharo/vm/build-vm.nix

···
-{ stdenv, fetchurl, bash, unzip, glibc, openssl, libGLU_combined, freetype, xorg, alsaLib, cairo, libuuid, autoreconfHook, gcc48, ... }:
+{ stdenv
+, fetchurl
+, bash
+, unzip
+, glibc
+, openssl
+, libgit2
+, libGLU_combined
+, freetype
+, xorg
+, alsaLib
+, cairo
+, libuuid
+, autoreconfHook
+, gcc48
+, ... }:
 
 { name, src, version, source-date, source-url, ... }:
 
···
 
   # (No special build phase.)
 
-  installPhase = ''
+  installPhase = let
+    libs = [
+      cairo
+      libgit2
+      libGLU_combined
+      freetype
+      openssl
+      libuuid
+      alsaLib
+      xorg.libICE
+      xorg.libSM
+    ];
+  in ''
     # Install in working directory and then copy
     make install-squeak install-plugins prefix=$(pwd)/products
 
···
     mkdir -p "$out/bin"
 
     # Note: include ELF rpath in LD_LIBRARY_PATH for finding libc.
-    libs=$out:$(patchelf --print-rpath "$out/pharo"):${cairo}/lib:${libGLU_combined}/lib:${freetype}/lib:${openssl}/lib:${libuuid}/lib:${alsaLib}/lib:${xorg.libICE}/lib:${xorg.libSM}/lib
+    libs=$out:$(patchelf --print-rpath "$out/pharo"):${stdenv.lib.makeLibraryPath libs}
 
     # Create the script
     cat > "$out/bin/${cmd}" <<EOF
···
     LD_LIBRARY_PATH="\$LD_LIBRARY_PATH:$libs" exec $out/pharo "\$@"
     EOF
     chmod +x "$out/bin/${cmd}"
+    ln -s ${libgit2}/lib/libgit2.so* "$out/"
   '';
 
   enableParallelBuilding = true;
···
   #
   # (stack protection is disabled above for gcc 4.8 compatibility.)
   nativeBuildInputs = [ autoreconfHook ];
-  buildInputs = [ bash unzip glibc openssl gcc48 libGLU_combined freetype xorg.libX11 xorg.libICE xorg.libSM alsaLib cairo pharo-share libuuid ];
+  buildInputs = [
+    bash
+    unzip
+    glibc
+    openssl
+    gcc48
+    libGLU_combined
+    freetype
+    xorg.libX11
+    xorg.libICE
+    xorg.libSM
+    alsaLib
+    cairo
+    pharo-share
+    libuuid
+  ];
 
   meta = with stdenv.lib; {
     description = "Clean and innovative Smalltalk-inspired environment";

pkgs/development/pharo/vm/vms.nix

···
-{ cmake, stdenv, fetchurl, bash, unzip, glibc, openssl, gcc, libGLU_combined, freetype, xorg, alsaLib, cairo, libuuid, autoreconfHook, gcc48, fetchFromGitHub, makeWrapper} @args:
+{ cmake
+, stdenv
+, fetchurl
+, bash
+, unzip
+, glibc
+, openssl
+, gcc
+, libgit2
+, libGLU_combined
+, freetype
+, xorg
+, alsaLib
+, cairo
+, libuuid
+, autoreconfHook
+, gcc48
+, fetchFromGitHub
+, makeWrapper
+} @args:
 
 let
   pharo-vm-build = import ./build-vm.nix args;

pkgs/development/python-modules/absl-py/default.nix

···
 { buildPythonPackage
 , lib
+, pythonOlder
 , fetchPypi
 , six
+, enum34
 }:
 
 buildPythonPackage rec {
···
     sha256 = "87519e3b91a3d573664c6e2ee33df582bb68dca6642ae3cf3a4361b1c0a4e9d6";
   };
 
-  propagatedBuildInputs = [ six ];
+  propagatedBuildInputs = [
+    six
+  ] ++ lib.optionals (pythonOlder "3.4") [
+    enum34
+  ];
 
   # checks use bazel; should be revisited
   doCheck = false;

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

···
 # wrapped to be able to find aioconsole and any other packages.
 buildPythonPackage rec {
   pname = "aioconsole";
-  version = "0.1.10";
+  version = "0.1.11";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "3fab07073648d70d8345e0eb745bd81fcd02b5e2b080c4663faea8c8ab281c0a";
+    sha256 = "0xjfx7fnmc9c8s1agj5mva3api4dywrf1q81yccb1gk7ifrrn04c";
   };
 
   # hardcodes a test dependency on an old version of pytest-asyncio

pkgs/development/python-modules/azure-mgmt-compute/default.nix

···
 }:
 
 buildPythonPackage rec {
-  version = "4.3.1";
+  version = "0.20.0";
   pname = "azure-mgmt-compute";
 
   src = fetchPypi {
     inherit pname version;
     extension = "zip";
-    sha256 = "5b0c2390af3e29d910e3d6e7a72b0be59d6e15933740dd193129217c000e4fed";
+    sha256 = "12hr5vxdg2sk2fzr608a37f4i8nbchca7dgdmly2w5fc7x88jx2v";
   };
 
   preConfigure = ''

pkgs/development/python-modules/azure-mgmt-network/default.nix

···
 }:
 
 buildPythonPackage rec {
-  version = "2.2.1";
+  version = "0.20.1";
   pname = "azure-mgmt-network";
 
   src = fetchPypi {
     inherit pname version;
     extension = "zip";
-    sha256 = "a4327bccc435ca4f829ac18f82f17923b490958c202af7a86044ccabeaaa5401";
+    sha256 = "10vj22h6nxpw0qpvib5x2g6qs5j8z31142icvh4qk8k40fcrs9hx";
   };
 
   preConfigure = ''

pkgs/development/python-modules/azure-mgmt-nspkg/default.nix

···
 }:
 
 buildPythonPackage rec {
-  version = "3.0.2";
+  version = "1.0.0";
   pname = "azure-mgmt-nspkg";
 
   src = fetchPypi {
     inherit pname version;
     extension = "zip";
-    sha256 = "8b2287f671529505b296005e6de9150b074344c2c7d1c805b3f053d081d58c52";
+    sha256 = "1rq92fj3kvnqkk18596dybw0kvhgscvc6cd8hp1dhy3wrkqnhwmq";
   };
 
   propagatedBuildInputs = [ azure-nspkg ];

pkgs/development/python-modules/azure-mgmt-resource/default.nix

···
 
 
 buildPythonPackage rec {
-  version = "2.0.0";
+  version = "0.20.1";
   pname = "azure-mgmt-resource";
 
   src = fetchPypi {
     inherit pname version;
     extension = "zip";
-    sha256 = "2e83289369be88d0f06792118db5a7d4ed7150f956aaae64c528808da5518d7f";
+    sha256 = "0slh9qfm5nfacrdm3lid0sr8kwqzgxvrwf27laf9v38kylkfqvml";
   };
 
   preConfigure = ''

pkgs/development/python-modules/azure-mgmt-storage/default.nix

···
 }:
 
 buildPythonPackage rec {
-  version = "3.0.0";
+  version = "0.20.0";
   pname = "azure-mgmt-storage";
 
   src = fetchPypi {
     inherit pname version;
     extension = "zip";
-    sha256 = "24c52b9dcb5e224ca9572d6ec39b53d332bdfe01818e85ec1cc1b5bedf16ce07";
+    sha256 = "16iw7hqhq97vlzfwixarfnirc60l5mz951p57brpcwyylphl3yim";
   };
 
   preConfigure = ''

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

···
-{ stdenv, fetchPypi
+{ stdenv, fetchPypi, fetchpatch
 , buildPythonApplication, python, pythonOlder
 , mock, nose, pathpy, pyhamcrest, pytest
 , glibcLocales, parse, parse-type, six
···
     inherit pname version;
     sha256 = "11hsz365qglvpp1m1w16239c3kiw15lw7adha49lqaakm8kj6rmr";
   };
+
+  patches = [
+    # Fix tests on Python 2.7
+    (fetchpatch {
+      url = https://github.com/behave/behave/commit/0a9430a94881cd18437deb03d2ae23afea0f009c.patch;
+      sha256 = "1nrh9ii6ik6gw2kjh8a6jk4mg5yqw3jfjfllbyxardclsab62ydy";
+    })
+  ];
 
   checkInputs = [ mock nose pathpy pyhamcrest pytest ];
   buildInputs = [ glibcLocales ];

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

···
-{ lib, buildPythonPackage, fetchPypi
+{ lib, buildPythonPackage, fetchPypi, isPy3k
 , cheroot, contextlib2, portend, routes, six
 , setuptools_scm, zc_lockfile
 , backports_unittest-mock, objgraph, pathpy, pytest, pytestcov
···
 buildPythonPackage rec {
   pname = "CherryPy";
   version = "18.0.1";
+
+  disabled = !isPy3k;
 
   src = fetchPypi {
     inherit pname version;

pkgs/development/python-modules/cli-helpers/default.nix

···
 { lib
 , buildPythonPackage
 , fetchPypi
+, configobj
 , terminaltables
 , tabulate
 , backports_csv
 , wcwidth
 , pytest
+, mock
 , isPy27
 }:
 
···
   };
 
   propagatedBuildInputs = [
+    configobj
     terminaltables
     tabulate
     wcwidth
   ] ++ (lib.optionals isPy27 [ backports_csv ]);
 
-  checkInputs = [ pytest ];
+  checkInputs = [ pytest mock ];
 
   checkPhase = ''
     py.test

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

···
 buildPythonPackage rec {
   pname = "cypari2";
   # upgrade may break sage, please test the sage build or ping @timokau on upgrade
-  version = "2.0.1";
+  version = "1.3.1";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "32fad615d773e9b5a9394c078ddc2c868e64e35f1ac9633ff90b456901b9d886";
+    sha256 = "04f00xp8aaz37v00iqg1mv5wjq00a5qhk8cqa93s13009s9x984r";
   };
 
   # This differs slightly from the default python installPhase in that it pip-installs

pkgs/development/python-modules/django/1_11.nix

···
 
 buildPythonPackage rec {
   pname = "Django";
-  version = "1.11.16";
+  version = "1.11.17";
 
   disabled = pythonOlder "2.7";
 
   src = fetchurl {
-    url = "http://www.djangoproject.com/m/releases/1.11/${pname}-${version}.tar.gz";
-    sha256 = "14apywfi8mfy50xh07cagp24kx9mlqfzfq4f60klz90ng328q9i9";
+    url = "https://www.djangoproject.com/m/releases/1.11/${pname}-${version}.tar.gz";
+    sha256 = "10xlpm21ll8mgz5py41sz9vrd603qv7an736agbqxkxlyikfx1x7";
   };
 
   patches = stdenv.lib.optionals withGdal [
···
   # too complicated to setup
   doCheck = false;
 
-  meta = {
+  meta = with stdenv.lib; {
     description = "A high-level Python Web framework";
     homepage = https://www.djangoproject.com/;
+    license = licenses.bsd3;
   };
 }

pkgs/development/python-modules/django/1_8.nix

···
 
 buildPythonPackage rec {
   name = "Django-${version}";
-  version = "1.8.18";
-  disabled = pythonOlder "2.7";
+  version = "1.8.19";
 
   src = fetchurl {
     url = "http://www.djangoproject.com/m/releases/1.8/${name}.tar.gz";
-    sha256 = "1ishvbihr9pain0486qafb18dnb7v2ppq34nnx1s8f95bvfiqqf7";
+    sha256 = "0iy0ni9j1rnx9b06ycgbg2dkrf3qid3y2jipk9x28cykz5f4mm1k";
   };
 
   # too complicated to setup

pkgs/development/python-modules/django/2_1.nix

···
 
 buildPythonPackage rec {
   pname = "Django";
-  version = "2.1.3";
+  version = "2.1.4";
 
   disabled = !isPy3k;
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "05k990b9zbj0nfkdcn13f5hg7ppfx9vffz5s0m66imd3mmlb5yhz";
+    sha256 = "1mxbrqdzim3xcy18dmd08xh2am0q7whbf0nf6bmnrl43802m3386";
   };
 
   patches = stdenv.lib.optionals withGdal [

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

···
 
 buildPythonPackage rec {
   pname = "dominate";
-  version = "2.3.4";
+  version = "2.3.5";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "8dfcca2bde3937a2d03db6e55efcb0c0dea0d4ab0923dc983d794b19e9247328";
+    sha256 = "0lda2a4nxxh9wp727vhn31rl5v7y9fxkscdjawg7gzj50xf76xj0";
   };
 
   doCheck = !isPy3k;

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

···
 
 buildPythonPackage rec {
   pname = "dropbox";
-  version = "9.1.0";
+  version = "9.2.0";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "0j6p5hgbglpwqd4jl53iqs83537464lybzc0aszi3w6wm6i0dlyq";
+    sha256 = "121wn4l6f6r4vm7yq0y9d1xsn5y77l6a4vgakyy2yaz8wv6j9w7c";
   };
 
   # Set DROPBOX_TOKEN environment variable to a valid token.

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

···
 
 buildPythonPackage rec {
   pname = "elpy";
-  version = "1.26.0";
+  version = "1.27.0";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "1m3dk609sn1j8zk8xwrlgcw82vkpws4q4aypv2ljpky9lm36npv6";
+    sha256 = "0fpxxmxjzcam3kharbmvprf4kagspya1rx9piacmxbgcp6w2lc4s";
   };
 
   propagatedBuildInputs = [ flake8 autopep8 jedi importmagic ]

pkgs/development/python-modules/facebook-sdk/default.nix

···
 
 buildPythonPackage rec {
   pname = "facebook-sdk";
-  version = "3.0.0";
+  version = "3.1.0";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "f3d450ec313b62d3716fadc4e5098183760e1d2a9e0434a94b74e59ea6ea3e4d";
+    sha256 = "138grz0n6plzdqgi4h6hhszf58bsvx9v76cwj51g1nd3kvkd5g6a";
   };
 
   propagatedBuildInputs = [ requests ];

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

···
+{ stdenv, buildPythonPackage, fetchPypi,
+  requests, mt-940, sepaxml, bleach, isPy3k }:
+
+buildPythonPackage rec {
+  version = "2.0.0";
+  pname = "fints";
+  disabled = !isPy3k;
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "1jja83h0ld55djiphcxdz64z5qp3w94204bfbgg65v5ybw0vpqq1";
+  };
+
+  propagatedBuildInputs = [ requests mt-940 sepaxml bleach ];
+
+  # no tests included in PyPI package
+  doCheck = false;
+
+  meta = with stdenv.lib; {
+    homepage = https://github.com/raphaelm/python-fints/;
+    description = "Pure-python FinTS (formerly known as HBCI) implementation";
+    license = licenses.lgpl3;
+    maintainers = with maintainers; [ elohmeier ];
+  };
+}

pkgs/development/python-modules/flask-migrate/default.nix

···
 
 buildPythonPackage rec {
   pname = "Flask-Migrate";
-  version = "2.3.0";
+  version = "2.3.1";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "19rxhva9i5n643vm3d11f8p98jwai2pavysa217p5w5h5cnksnx2";
+    sha256 = "1awlb4q1l9iv794qjjxxyhcv4i69j77kh7nsg17a6kb909mglml3";
   };
 
   checkInputs = optional isPy3k glibcLocales;

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

···
   };
 
   disabled = !isPy3k;
-  propagatedBuildInputs = [ docutils requests requests_download pytoml ] ++ lib.optional (pythonOlder "3.6") zipfile36;
+  propagatedBuildInputs = [ docutils requests requests_download pytoml ]
+    ++ lib.optional (pythonOlder "3.6") zipfile36;
 
   checkInputs = [ pytest testpath responses ];
 
   # Disable test that needs some ini file.
   # Disable test that wants hg
   checkPhase = ''
-    py.test -k "not test_invalid_classifier and not test_build_sdist"
+    HOME=$(mktemp -d) pytest -k "not test_invalid_classifier and not test_build_sdist"
   '';
 
   meta = {

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

···
 
 buildPythonPackage rec {
   pname = "folium";
-  version = "0.6.0";
+  version = "0.7.0";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "08681be47b1861221bc7cf17b6e368a8d734db81682d716c22a11e839f47cb79";
+    sha256 = "04mhdl3k644j45rlfkamxz1paf58fxrmnwgvkrvza2fcwcs4nr9n";
   };
 
   checkInputs = [ pytest nbconvert pandas mock ];

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

···
-{ stdenv
+{ lib
+, pythonOlder
 , buildPythonPackage
 , fetchPypi
+, betamax
+, pytest
+, betamax-matchers
 , unittest2
-, pytest
 , mock
-, betamax
-, betamax-matchers
-, dateutil
 , requests
-, pyopenssl
 , uritemplate
+, dateutil
+, jwcrypto
+, pyopenssl
 , ndg-httpsclient
 , pyasn1
-, jwcrypto
 }:
 
 buildPythonPackage rec {
···
     sha256 = "35fea5bf3567a8e88d3660686d83f96ef164e698ce6fb30f9e2b0edded7357af";
   };
 
-  buildInputs = [ unittest2 pytest mock betamax betamax-matchers dateutil ];
+  checkInputs = [ betamax pytest betamax-matchers ]
+    ++ lib.optional (pythonOlder "3") unittest2
+    ++ lib.optional (pythonOlder "3.3") mock;
   propagatedBuildInputs = [ requests uritemplate dateutil jwcrypto pyopenssl ndg-httpsclient pyasn1 ];
 
   postPatch = ''
-    sed -i -e 's/mock ==1.0.1/mock>=1.0.1/' setup.py
     sed -i -e 's/unittest2 ==0.5.1/unittest2>=0.5.1/' setup.py
   '';
 
   # TODO: only disable the tests that require network
   doCheck = false;
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = http://github3py.readthedocs.org/en/master/;
     description = "A wrapper for the GitHub API written in python";
     license = licenses.bsd3;

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

···
 
 buildPythonPackage rec {
   pname = "google-cloud-vision";
-  version = "0.34.0";
+  version = "0.35.1";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "50392b2c68e40dbf725c531ba4d325bd910da6441a472ed0a3fadfd0ab8548f7";
+    sha256 = "0hx80q8rcgs0kvhv0xix2dhr3n19abac4sj4k5pfqxh6qzdxm3d8";
   };
 
   checkInputs = [ pytest mock ];

pkgs/development/python-modules/graphite-web/default.nix

···
 { stdenv, buildPythonPackage, fetchPypi, isPy3k, which
 , django, django_tagging, whisper, pycairo, cairocffi, ldap, memcached, pytz, urllib3, scandir
 }:
-if django.version != "1.8.18"
+if django.version != "1.8.19"
 || django_tagging.version != "0.4.3"
 then throw "graphite-web should be build with django_1_8 and django_tagging_0_4_3"
 else buildPythonPackage rec {

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

···
 { lib
 , buildPythonPackage
 , fetchPypi
+, fetchpatch
 , ipython
 , jupyter_client
 , traitlets
···
 
   checkInputs = [ pytest nose ];
   propagatedBuildInputs = [ ipython jupyter_client traitlets tornado ];
+
+  # https://github.com/ipython/ipykernel/pull/377
+  patches = [
+    (fetchpatch {
+      url = "https://github.com/ipython/ipykernel/commit/a3bf849dbd368a1826deb9dfc94c2bd3e5ed04fe.patch";
+      sha256 = "1yhpwqixlf98a3n620z92mfips3riw6psijqnc5jgs2p58fgs2yc";
+    })
+  ];
 
   checkPhase = ''
     HOME=$(mktemp -d) pytest ipykernel

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

···
+{ lib
+, buildPythonPackage
+, fetchPypi
+, testfixtures
+, pyyaml
+, mock
+, nbformat
+, pytest
+}:
+
+buildPythonPackage rec {
+  pname = "jupytext";
+  version = "0.8.6";
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "1m35m9z4vy480d2200nd4lk9n5s4z3zcnq0d9rdlh4yv5264mrgf";
+  };
+
+  propagatedBuildInputs = [
+    pyyaml
+    nbformat
+    testfixtures
+  ];
+  checkInputs = [
+    pytest
+  ];
+  # setup.py checks for those even though they're not needed at runtime (only
+  # for tests), thus not propagated
+  buildInputs = [
+    mock
+    pytest
+  ];
+
+  # requires test notebooks which are not shipped with the pypi release
+  doCheck = false;
+  checkPhase = ''
+    py.test
+  '';
+
+  meta = with lib; {
+    description = "Jupyter notebooks as Markdown documents, Julia, Python or R scripts";
+    homepage = https://github.com/mwouts/jupytext;
+    license = licenses.mit;
+    maintainers = with maintainers; [ timokau ];
+  };
+}

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

···
 { stdenv, buildPythonPackage, fetchPypi, pytest, six, mock }:
 
 buildPythonPackage rec {
-  version = "1.4.3";
+  version = "1.4.4";
   pname = "kafka-python";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "078acdcd1fc6eddacc46d437c664998b4cf7613b7e79ced66a460965f2648f88";
+    sha256 = "1p9sr9vl96xz8qrgdrjiql9qkch2qx29pkq7igk28clgc6zbn510";
   };
 
   checkInputs = [ pytest six mock ];

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

···
   #
   # {test_locals,test_socket_path} fail to remove /tmp/manhole-socket
   # on the x86_64-darwin builder.
-  doCheck = stdenv.isLinux;
+  #
+  # TODO: change this back to `doCheck = stdenv.isLinux` after
+  # https://github.com/ionelmc/python-manhole/issues/54 is fixed
+  doCheck = false;
 
   checkInputs = [ pytest requests process-tests ];
   checkPhase = ''

pkgs/development/python-modules/mt-940/default.nix

···
-{ buildPythonPackage, stdenv, pytestrunner, pyyaml, pytest, enum34
-, pytestpep8, pytestflakes,fetchFromGitHub, isPy3k, lib, glibcLocales
+{ buildPythonPackage, stdenv, pyyaml, pytest, enum34
+, pytestpep8, pytestflakes, fetchFromGitHub, isPy3k, lib, glibcLocales
 }:
 
 buildPythonPackage rec {
-  version = "4.10.0";
-  pname = "mt940";
+  version = "4.12.2";
+  pname = "mt-940";
 
   src = fetchFromGitHub {
     owner = "WoLpH";
-    repo = pname;
+    repo = "mt940";
     rev = "v${version}";
-    sha256 = "1dsf2di8rr0iw2vaz6dppalby3y7i8x2bl0qjqvaiqacjxxvwj65";
+    sha256 = "0l7q8v00dhpbc9mh6baaaqc55kf44rszygx28dq3pwp5b5x33nir";
   };
 
-  patches = [
-    ./no-coverage.patch
-  ];
+  postPatch = ''
+    # No coverage report
+    sed -i "/--\(no-\)\?cov/d" pytest.ini
+  '';
 
-  propagatedBuildInputs = [ pyyaml pytestrunner ]
-    ++ lib.optional (!isPy3k) enum34;
+  propagatedBuildInputs = lib.optional (!isPy3k) enum34;
 
   LC_ALL="en_US.UTF-8";
 
-  checkInputs = [ pytestpep8 pytestflakes pytest glibcLocales ];
+  checkInputs = [ pyyaml pytestpep8 pytestflakes pytest glibcLocales ];
+
+  # See https://github.com/WoLpH/mt940/issues/64 for the disabled test
   checkPhase = ''
-    py.test
+    py.test -k "not mt940.models.FixedOffset"
   '';
 
   meta = with stdenv.lib; {
     description = "A library to parse MT940 files and returns smart Python collections for statistics and manipulation";
-    homepage = https://pythonhosted.org/mt-940/;
+    inherit (src.meta) homepage;
     license = licenses.bsd3;
   };
 }

pkgs/development/python-modules/mt-940/no-coverage.patch

···
-diff --git a/pytest.ini b/pytest.ini
-index fef28f5..f366331 100644
---- a/pytest.ini
-+++ b/pytest.ini
-@@ -4,10 +4,6 @@ python_files =
-     tests/*.py
- 
- addopts =
--    --cov mt940
--    --cov-report term-missing
--    --cov-report html
--    --no-cov-on-fail
-     --doctest-modules
-     --pep8
-     --flakes
-diff --git a/tests/requirements.txt b/tests/requirements.txt
-index fc55572..e52cc28 100644
---- a/tests/requirements.txt
-+++ b/tests/requirements.txt
-@@ -3,6 +3,5 @@
- -r ../docs/requirements.txt
- pytest
- pytest-cache
--pytest-cover
- pytest-flakes
- pytest-pep8

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

···
 
 buildPythonPackage rec {
   pname = "mysqlclient";
-  version = "1.3.13";
+  version = "1.3.14";
 
   buildInputs = [
     mysql.connector-c
···
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "ff8ee1be84215e6c30a746b728c41eb0701a46ca76e343af445b35ce6250644f";
+    sha256 = "0symgjmzkckzsxx3piaxywls8q19s1pdgbmpm0v1m425wnfax09r";
   };
 
   meta = with stdenv.lib; {

pkgs/development/python-modules/nose-randomly/default.nix

···
     nose
   ];
 
+  checkPhase = ''
+    nosetests
+  '';
+
   meta = with lib; {
     description = "Nose plugin to randomly order tests and control random.seed";
     homepage = https://github.com/adamchainz/nose-randomly;

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

···
 , fetchPypi
 , python
 , numpy
-, llvmPackages ? null
 }:
 
 buildPythonPackage rec {
···
   };
 
   # Remove existing site.cfg, use the one we built for numpy.
-  # Somehow openmp needs to be added to LD_LIBRARY_PATH
-  # https://software.intel.com/en-us/forums/intel-system-studio/topic/611682
   preBuild = ''
     rm site.cfg
     ln -s ${numpy.cfg} site.cfg
-    export LD_LIBRARY_PATH=${llvmPackages.openmp}/lib
   '';
 
-  buildInputs = [] ++ lib.optional (numpy.blasImplementation == "mkl") llvmPackages.openmp;
-
   propagatedBuildInputs = [ numpy ];
 
   # Run the test suite.
···
     homepage = "https://github.com/pydata/numexpr";
     license = lib.licenses.mit;
   };
-}
+}

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

···
     inherit blasImplementation cfg;
   };
 
-  doCheck = blasImplementation != "mkl";
-
   # Disable two tests
   # - test_f2py: f2py isn't yet on path.
   # - test_large_file_support: takes a long time and can cause the machine to run out of disk space

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

···
 { stdenv
 , buildPythonPackage
 , fetchPypi
-, pkgs
 , isPyPy
+, graphviz
+, mock
 }:
 
 buildPythonPackage rec {
···
   # Tests fail with PyPy.
   disabled = isPyPy;
 
-  propagatedBuildInputs = [pkgs.graphviz];
+  propagatedBuildInputs = [ graphviz ];
+
+  checkInputs = [ mock ];
 
   meta = with stdenv.lib; {
     description = "Draws Python object reference graphs with graphviz";

pkgs/development/python-modules/path.py/default.nix

···
 , buildPythonPackage
 , fetchPypi
 , setuptools_scm
-, pytestrunner
 , pytest
+, pytest-flake8
 , glibcLocales
 , packaging
 , isPy27
···
 buildPythonPackage rec {
   pname = "path.py";
   version = "11.5.0";
-  name = pname + "-" + version;
 
   src = fetchPypi {
     inherit pname version;
     sha256 = "b6687a532a735a2d79a13e92bdb31cb0971abe936ea0fa78bcb47faf4372b3cb";
   };
 
-  checkInputs = [ pytest pytestrunner glibcLocales packaging ];
+  checkInputs = [ pytest pytest-flake8 glibcLocales packaging ];
   buildInputs = [ setuptools_scm ];
   propagatedBuildInputs = [
     importlib-metadata
···
   };
 
   checkPhase = ''
-    # Ignore pytest configuration
-    rm pytest.ini
-    py.test test_path.py
+    # ignore performance test which may fail when the system is under load
+    py.test -v -k 'not TestPerformance'
   '';
 }

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

···
 , buildPythonPackage
 , fetchPypi
 , pytz
+, six
 }:
 
 buildPythonPackage rec {
···
     sha256 = "18192d90409a3037619ef17f1924e3fd9c7169c9c1b3277cec1982116ec2b6de";
   };
 
-  propagatedBuildInputs = [ pytz ];
+  propagatedBuildInputs = [ pytz six ];
 
   meta = with stdenv.lib; {
-    homepage = https://github.com/realazthat/aiopg8000;
+    homepage = https://github.com/mfenniak/pg8000;
     description = "PostgreSQL interface library, for asyncio";
     maintainers = with maintainers; [ garbas domenkozar ];
     platforms = platforms.linux;

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

···
-{ buildPythonPackage, stdenv, lxml, click, fetchPypi }:
+{ buildPythonPackage, stdenv, lxml, click, fetchFromGitHub, pytest, isPy3k }:
 
 buildPythonPackage rec {
   version = "0.3.13";
   pname = "pyaxmlparser";
 
-  src = fetchPypi {
-    inherit pname version;
-    sha256 = "1mzdrifnaky57vkmdvg0rgjss55xkxaramci3wpv4h65lmk95988";
+  # the PyPI tarball doesn't ship tests.
+  src = fetchFromGitHub {
+    owner = "appknox";
+    repo = pname;
+    rev = "v${version}";
+    sha256 = "0jfjhxc6b57npsidknxmhj1x813scg47aaw90ybyr90fpdz5rlwk";
   };
 
+  disabled = !isPy3k;
+
+  postPatch = ''
+    substituteInPlace setup.py --replace "click==6.7" "click"
+  '';
+
   propagatedBuildInputs = [ lxml click ];
+
+  checkInputs = [ pytest ];
+  checkPhase = ''
+    py.test tests/
+  '';
 
   meta = with stdenv.lib; {
     description = "Python3 Parser for Android XML file and get Application Name without using Androguard";

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

···
-{ lib, buildPythonPackage, fetchPypi, nose, numpy }:
+{ lib, buildPythonPackage, fetchPypi, cython, nose, numpy }:
 
 buildPythonPackage rec {
   pname = "pyjet";
···
     inherit pname version;
     sha256 = "1glcwv9ni8i40smfw6m456xjadlkackim5nk33xmas1fa96lpagg";
   };
+
+  # fix for python37
+  # https://github.com/scikit-hep/pyjet/issues/8
+  nativeBuildInputs = [ cython ];
+  preBuild = ''
+    for f in pyjet/src/*.{pyx,pxd}; do
+      cython --cplus "$f"
+    done
+  '';
 
   propagatedBuildInputs = [ numpy ];
   checkInputs = [ nose ];

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

···
 , buildPythonPackage
 , fetchurl
 , isPyPy
-, pkgs
+, liblo
+, cython
 }:
 
 buildPythonPackage rec {
   pname = "pyliblo";
-  version = "0.9.2";
+  version = "0.10.0";
   disabled = isPyPy;
 
   src = fetchurl {
     url = "http://das.nasophon.de/download/${pname}-${version}.tar.gz";
-    sha256 = "382ee7360aa00aeebf1b955eef65f8491366657a626254574c647521b36e0eb0";
+    sha256 = "13vry6xhxm7adnbyj28w1kpwrh0kf7nw83cz1yq74wl21faz2rzw";
   };
 
-  propagatedBuildInputs = [ pkgs.liblo ];
+  buildInputs = [ liblo cython ];
 
   meta = with stdenv.lib; {
     homepage = http://das.nasophon.de/pyliblo/;

pkgs/development/python-modules/pyqt/5.x.nix

···
   '';
 
   postInstall = ''
+    ln -s ${sip}/${python.sitePackages}/PyQt5/* $out/${python.sitePackages}/PyQt5
     for i in $out/bin/*; do
       wrapProgram $i --prefix PYTHONPATH : "$PYTHONPATH"
     done

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

···
 
 buildPythonPackage rec {
   pname = "raven";
-  version = "6.9.0";
+  version = "6.10.0";
 
   src = fetchFromGitHub {
     owner = "getsentry";
     repo = "raven-python";
     rev = version;
-    sha256 = "1kggp34i8gqi47khca2v5n2i32zrg66m1pga6c00yqmlbv74d84v";
+    sha256 = "16x9ldl8cy7flw5kh7qmgbmflqyf210j3q6ac2lw61sgwajsnvw8";
   };
 
   # way too many dependencies to run tests

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

···
 , buildPythonPackage
 , fetchPypi
 , ruamel_base
-, typing
 , ruamel_ordereddict
 , isPy3k
 }:
···
   # Tests cannot load the module to test
   doCheck = false;
 
-  propagatedBuildInputs = [ ruamel_base typing ]
+  propagatedBuildInputs = [ ruamel_base ]
     ++ stdenv.lib.optional (!isPy3k) ruamel_ordereddict;
 
   meta = with stdenv.lib; {

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

···
 { stdenv, buildPythonPackage, fetchPypi, glibcLocales, mock, pytest, botocore,
   testfixtures, pillow, six, twisted, w3lib, lxml, queuelib, pyopenssl,
-  service-identity, parsel, pydispatcher, cssselect, lib }:
+  service-identity, parsel, pydispatcher, cssselect, lib, fetchpatch }:
 buildPythonPackage rec {
   version = "1.5.1";
   pname = "Scrapy";
···
     six twisted w3lib lxml cssselect queuelib pyopenssl service-identity parsel pydispatcher
   ];
 
-  # Scrapy is usually installed via pip where copying all
-  # permissions makes sense. In Nix the files copied are owned by
-  # root and readonly. As a consequence scrapy can't edit the
-  # project templates.
-  patches = [ ./permissions-fix.patch ];
+  patches = [
+    # Scrapy is usually installed via pip where copying all
+    # permissions makes sense. In Nix the files copied are owned by
+    # root and readonly. As a consequence scrapy can't edit the
+    # project templates.
+    ./permissions-fix.patch
+    # fix python37 issues. Remove with the next release
+    (fetchpatch {
+      url = https://github.com/scrapy/scrapy/commit/f4f39057cbbfa4daf66f82061e57101b88d88d05.patch;
+      sha256 = "1f761qkji362i20i5bzcxz44sihvl29prm02i5l2xyhgl1hp91hv";
+    })
+  ];
 
   LC_ALL="en_US.UTF-8";
 
+  # Ignore proxy tests because requires mitmproxy
+  # Ignore test_retry_dns_error because tries to resolve an invalid dns and weirdly fails with "Reactor was unclean"
+  # Ignore xml encoding test on darwin because lxml can't find encodings https://bugs.launchpad.net/lxml/+bug/707396
   checkPhase = ''
-    py.test --ignore=tests/test_linkextractors_deprecated.py --ignore=tests/test_proxy_connect.py ${lib.optionalString stdenv.isDarwin "--ignore=tests/test_utils_iterators.py"}
-    # The ignored tests require mitmproxy, which depends on protobuf, but it's disabled on Python3
-    # Ignore iteration test, because lxml can't find encodings on darwin https://bugs.launchpad.net/lxml/+bug/707396
+    pytest --ignore=tests/test_linkextractors_deprecated.py --ignore=tests/test_proxy_connect.py --deselect tests/test_crawl.py::CrawlTestCase::test_retry_dns_error ${lib.optionalString stdenv.isDarwin "--deselect tests/test_utils_iterators.py::LxmlXmliterTestCase::test_xmliter_encoding"}
   '';
 
   src = fetchPypi {
···
     sha256 = "5a398bf6818f87dcc817c919408a195f19ba46414ae12f259119336cfa862bb6";
   };
 
+  postInstall = ''
+    install -m 644 -D extras/scrapy.1 $out/share/man/man1/scrapy.1
+    install -m 644 -D extras/scrapy_bash_completion $out/share/bash-completion/completions/scrapy
+    install -m 644 -D extras/scrapy_zsh_completion $out/share/zsh/site-functions/_scrapy
+  '';
+
   meta = with lib; {
     description = "A fast high-level web crawling and web scraping framework, used to crawl websites and extract structured data from their pages";
     homepage = https://scrapy.org/;
     license = licenses.bsd3;
-    maintainers = with maintainers; [ drewkett ];
+    maintainers = with maintainers; [ drewkett marsam ];
     platforms = platforms.unix;
   };
 }

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

···
+{ stdenv, buildPythonPackage, fetchPypi, isPy3k }:
+
+buildPythonPackage rec {
+  version = "2.0.0";
+  pname = "sepaxml";
+  disabled = !isPy3k;
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "0jhj8fa0lbyaw15q485kyyli9qgrmqr47a6z6pgqm40kwmjghiyc";
+  };
+
+  # no tests included in PyPI package
+  doCheck = false;
+
+  meta = with stdenv.lib; {
+    homepage = https://github.com/raphaelm/python-sepaxml/;
+    description = "SEPA Direct Debit XML generation in python";
+    license = licenses.mit;
+    maintainers = with maintainers; [ elohmeier ];
+  };
+}

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

···
-{ stdenv, buildPythonPackage, fetchPypi, coverage }:
+{ stdenv, buildPythonPackage, fetchPypi, python, coverage, lsof, glibcLocales }:
 
 buildPythonPackage rec {
   pname = "sh";
···
     sha256 = "1z2hx357xp3v4cv44xmqp7lli3frndqpyfmpbxf7n76h7s1zaaxm";
   };
 
-  checkInputs = [ coverage ];
+  # Disable tests that fail on Darwin
+  # Some of the failures are due to Nix using GNU coreutils
+  patches = [ ./disable-broken-tests-darwin.patch ];
+
+  postPatch = ''
+    sed -i 's#/usr/bin/env python#${python.interpreter}#' test.py
+  '';
+
+  checkInputs = [ coverage lsof glibcLocales ];
 
   # A test needs the HOME directory to be different from $TMPDIR.
   preCheck = ''
+    export LC_ALL="en_US.UTF-8"
     HOME=$(mktemp -d)
   '';
 

pkgs/development/python-modules/sh/disable-broken-tests-darwin.patch

···
+From 264f2f6a04d25156bba43524a6b172d2e99c53f4 Mon Sep 17 00:00:00 2001
+From: Ben Wolsieffer <[e-mail]>
+Date: Fri, 21 Dec 2018 17:39:45 -0500
+Subject: [PATCH] Disable tests that fail on OSX.
+
+Some of the failures are due to the use of GNU ls.
+---
+ test.py | 4 ++++
+ 1 file changed, 4 insertions(+)
+
+diff --git a/test.py b/test.py
+index 68ef40c..2f53360 100644
+--- a/test.py
++++ b/test.py
+@@ -352,6 +352,7 @@ exit(3)
+         self.assertEqual(sed(_in="one test three", e="s/test/two/").strip(),
+                 "one two three")
+ 
++    @not_osx
+     def test_ok_code(self):
+         from sh import ls, ErrorReturnCode_1, ErrorReturnCode_2
+ 
+@@ -498,6 +499,7 @@ while True:
+         self.assertEqual(out, match)
+ 
+ 
++    @not_osx
+     def test_environment(self):
+         """ tests that environments variables that we pass into sh commands
+         exist in the environment, and on the sh module """
+@@ -861,6 +863,7 @@ print(sys.argv[1])
+         self.assertTrue(now - start > sleep_time)
+ 
+ 
++    @not_osx
+     def test_background_exception(self):
+         from sh import ls, ErrorReturnCode_1, ErrorReturnCode_2
+         p = ls("/ofawjeofj", _bg=True) # should not raise
+@@ -2036,6 +2039,7 @@ else:
+         self.assertEqual(p, "test")
+ 
+ 
++    @not_osx
+     def test_signal_exception(self):
+         from sh import SignalException_15
+ 
+-- 
+2.20.0
+

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

···
 
   configurePhase = ''
     ${python.executable} ./configure.py \
+      --sip-module PyQt5.sip \
       -d $out/lib/${python.libPrefix}/site-packages \
       -b $out/bin -e $out/include
   '';

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

···
+{ lib
+, buildPythonPackage
+, isPy3k
+, fetchPypi
+, requests
+, lxml
+, beautifulsoup4
+}:
+
+buildPythonPackage rec {
+  pname = "snscrape";
+  version = "0.1.3";
+
+  disabled = !isPy3k;
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "1mnhqqc7xfwg2wrzpj1pjbcisjjwxrgmy21f53p80xbx2iz8b9n1";
+  };
+
+  # There are no tests; make sure the executable works.
+  checkPhase = ''
+    export PATH=$PATH:$out/bin
+    snscrape --help
+  '';
+
+  propagatedBuildInputs = [ requests lxml beautifulsoup4 ];
+
+  meta = with lib; {
+    homepage = https://github.com/JustAnotherArchivist/snscrape;
+    description = "A social networking service scraper in Python";
+    license = licenses.gpl3Plus;
+    maintainers = with maintainers; [ ivan ];
+  };
+}

pkgs/development/python-modules/sphinxcontrib-bibtex/default.nix

···
 }:
 
 buildPythonPackage rec {
-  version = "0.4.0";
+  version = "0.4.1";
   pname = "sphinxcontrib-bibtex";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "cb9fb4526642fc080204fccd5cd8f41e9e95387278e17b1d6969b1e27c2d3e0c";
+    sha256 = "0kx04bqjf9ilygrzpm2z9078nfnkmywpgwxl7idpzidkzirqsnsr";
   };
 
   propagatedBuildInputs = [ oset pybtex pybtex-docutils sphinx ];

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

···
 
 buildPythonPackage rec {
   pname = "thumbor";
-  version = "6.5.2";
+  version = "6.6.0";
 
   disabled = isPy3k; # see https://github.com/thumbor/thumbor/issues/1004
 
···
     owner = pname;
     repo = pname;
     rev = version;
-    sha256 = "1ys5ymwbvgh2ir85g9nyrzzf8vgi16j6pzzi53b0rgjx0kwlmnxg";
+    sha256 = "0m4q40fcha1aydyr1khjhnb08cdfma67yxgyhsvwar5a6sl0906i";
   };
 
   postPatch = ''
     substituteInPlace "setup.py" \
       --replace '"argparse",' "" ${lib.optionalString isPy3k ''--replace '"futures",' ""''}
-    substituteInPlace "setup.py" \
-      --replace "piexif>=1.0.13,<1.1.0" "piexif>=1.0.13"
+    sed -i setup.py \
+        -e 's/piexif[^"]*/piexif/;s/Pillow[^"]*/Pillow/'
     substituteInPlace "tests/test_utils.py" \
       --replace "/bin/ls" "${coreutils}/bin/ls"
     substituteInPlace "tests/detectors/test_face_detector.py" \

pkgs/development/python-modules/typed-ast/default.nix

···
 { buildPythonPackage, fetchPypi, lib, pythonOlder }:
 buildPythonPackage rec {
   pname = "typed-ast";
-  version = "1.1.0";
+  version = "1.1.1";
   src = fetchPypi{
     inherit pname version;
-    sha256 = "57fe287f0cdd9ceaf69e7b71a2e94a24b5d268b35df251a88fef5cc241bf73aa";
+    sha256 = "1iml3lcw50bz1fyw7s9sa4mqzbmqs5w43k6bsv5ix4vqa34mvckc";
   };
   # Only works with Python 3.3 and newer;
   disabled = pythonOlder "3.3";

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

···
-{ stdenv
-, buildPythonPackage
-, fetchPypi
-}:
-
-buildPythonPackage rec {
-  pname = "uritemplate.py";
-  version = "3.0.2";
-
-  src = fetchPypi {
-    inherit pname version;
-    sha256 = "e0cdeb0f55ec18e1580974e8017cd188549aacc2aba664ae756adb390b9d45b4";
-  };
-
-  meta = with stdenv.lib; {
-    homepage = https://github.com/uri-templates/uritemplate-py;
-    description = "Python implementation of URI Template";
-    license = licenses.asl20;
-    maintainers = with maintainers; [ pSub ];
-  };
-
-}

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

···
 { lib
 , buildPythonPackage
 , fetchPypi
+, six, h2
 , isPy3k
 }:
 
···
     sha256 = "9d0c6adc279748abea81ac12b7a2cac97ebbdd87826dc11f6dbd85b781e9442a";
   };
 
-  propagatedBuildInputs = [ ];
+  propagatedBuildInputs = [ six h2 ];
 
   meta = {
     description = "A webserver intended for web browser testing";

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

···
 
 buildPythonPackage rec {
   pname = "zeep";
-  version = "3.1.0";
+  version = "3.2.0";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "b2d96881689c3f29e8ea5c8c6abb2b17fb0f470deee15d0d7bec4e74592850f6";
+    sha256 = "0bfpdy3hi8aa45piwg5gj0xxa187v13d66qr1ki73qn7c6rbizp5";
   };
 
   propagatedBuildInputs = [

pkgs/development/ruby-modules/bundix/default.nix

···
     '';
     homepage = https://github.com/manveru/bundix;
     license = "MIT";
-    maintainers = with lib.maintainers; [ manveru zimbatm ];
+    maintainers = with lib.maintainers; [ manveru qyliss zimbatm ];
     platforms = lib.platforms.all;
   };
 }

pkgs/development/ruby-modules/bundler/default.nix

···
   inherit ruby;
   name = "${gemName}-${version}";
   gemName = "bundler";
-  version = "1.17.1";
-  source.sha256 = "0jmj67r2677mq8hxkhvlgpbv8gzfgdhxra3x0gf0bywiyypl546c";
+  version = "1.17.2";
+  source.sha256 = "0dbnq6703mjvgsri45vaw7b4wjqr89z1h8xkzsacqcp24a706m5r";
   dontPatchShebangs = true;
 
   postFixup = ''

pkgs/development/ruby-modules/gem-config/default.nix

···
 , cmake, libssh2, openssl, mysql, darwin, git, perl, pcre, gecode_3, curl
 , msgpack, qt59, libsodium, snappy, libossp_uuid, lxc, libpcap, xorg, gtk2, buildRubyGem
 , cairo, re2, rake, gobject-introspection, gdk_pixbuf, zeromq, graphicsmagick, libcxx, file
-, libselinux ? null, libsepol ? null
+, libselinux ? null, libsepol ? null, libvirt
 }@args:
 
 let
···
   rmagick = attrs: {
     nativeBuildInputs = [ pkgconfig ];
     buildInputs = [ imagemagick which ];
+  };
+
+  ruby-libvirt = attrs: {
+    buildInputs = [ libvirt pkgconfig ];
+    buildFlags = [
+      "--with-libvirt-include=${libvirt}/include"
+      "--with-libvirt-lib=${libvirt}/lib"
+    ];
   };
 
   ruby-lxc = attrs: {

pkgs/development/tools/ammonite/default.nix

···
 with stdenv.lib;
 stdenv.mkDerivation rec {
   name = "ammonite-${version}";
-  version = "1.5.0";
+  version = "1.6.0";
   scalaVersion = "2.12";
 
   src = fetchurl {
     url = "https://github.com/lihaoyi/Ammonite/releases/download/${version}/${scalaVersion}-${version}";
-    sha256 = "0ivfas9lfx3wsc2c4jxi1z54vn5f4cc4j1aqq53nxfl8sx2hbm3v";
+    sha256 = "17c6ps5i48hcjj7r6xw8mrqhy4cs7qsa787l36f30757hi1cx4qy";
   };
 
   propagatedBuildInputs = [ jre ] ;

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

···
 
 stdenv.mkDerivation rec {
   name = "pmd-${version}";
-  version = "6.9.0";
+  version = "6.10.0";
 
   buildInputs = [ unzip ];
 
   src = fetchurl {
     url = "mirror://sourceforge/pmd/pmd-bin-${version}.zip";
-    sha256 = "13w07f68gfcjy3a2zk4z4b0f95qscbkjlylckphmyxhw7vmgzlmn";
+    sha256 = "1yzgin2lbhfswb07mm14wq8rn129kpfjidd8nv9pg77ywhnbwqmb";
   };
 
   installPhase = ''

pkgs/development/tools/build-managers/bazel/default.nix

···
       find src/main/java/com/google/devtools -type f -print0 | while IFS="" read -r -d "" path; do
         substituteInPlace "$path" \
           --replace /bin/bash ${customBash}/bin/bash \
-          --replace /usr/bin/env ${coreutils}/bin/env
+          --replace /usr/bin/env ${coreutils}/bin/env \
+          --replace /bin/true ${coreutils}/bin/true
       done
       # Fixup scripts that generate scripts. Not fixed up by patchShebangs below.
       substituteInPlace scripts/bootstrap/compile.sh \

pkgs/development/tools/cloudfoundry-cli/default.nix

···
 
 buildGoPackage rec {
   name = "cloudfoundry-cli-${version}";
-  version = "6.37.0";
+  version = "6.41.0";
 
   goPackagePath = "code.cloudfoundry.org/cli";
 
···
     owner = "cloudfoundry";
     repo = "cli";
     rev = "v${version}";
-    sha256 = "1v4f1fyydpzkfir46g4ppbf3zmk3ym6kxswpkdjls8h3dbb2fbnv";
+    sha256 = "1dkd0lfq55qpnxsrigffaqm2nlcxr0bm0jsl4rsjlmb8p2vgpx8b";
   };
 
-  outputs = [ "out" ];
+  makeTarget = let hps = stdenv.hostPlatform.system; in
+    if hps == "x86_64-darwin" then
+      "out/cf-cli_osx"
+    else if hps == "x86_64-linux" then
+      "out/cf-cli_linux_x86-64"
+    else if hps == "i686-linux" then
+      "out/cf-cli_linux_i686"
+    else
+      throw "make target for this platform unknown";
 
   buildPhase = ''
     cd go/src/${goPackagePath}
-    CF_BUILD_DATE="1970-01-01" make build
+    CF_BUILD_DATE="1970-01-01" make $makeTarget
+    cp $makeTarget out/cf
   '';
 
   installPhase = ''
-    install -Dm555 out/cf "$out/bin/cf"
-    remove-references-to -t ${go} "$out/bin/cf"
-    install -Dm444 -t "$out/share/bash-completion/completions/" "$src/ci/installers/completion/cf"
+    install -Dm555 out/cf "$bin/bin/cf"
+    install -Dm444 -t "$bin/share/bash-completion/completions/" "$src/ci/installers/completion/cf"
   '';
 
   meta = with stdenv.lib; {
···
     homepage = https://github.com/cloudfoundry/cli;
     maintainers = with maintainers; [ ris ];
     license = licenses.asl20;
+    platforms = [ "i686-linux" "x86_64-linux" "x86_64-darwin" ];
   };
 }

pkgs/development/tools/database/liquibase/default.nix

···
 with stdenv.lib;
 let
   extraJars = optional mysqlSupport mysql_jdbc;
-
+  logback-core = fetchurl {
+    url = "http://central.maven.org/maven2/ch/qos/logback/logback-core/1.2.3/logback-core-1.2.3.jar";
+    sha256 = "5946d837fe6f960c02a53eda7a6926ecc3c758bbdd69aa453ee429f858217f22";
+  };
+  logback-classic = fetchurl {
+    url = "http://central.maven.org/maven2/ch/qos/logback/logback-classic/1.2.3/logback-classic-1.2.3.jar";
+    sha256 = "fb53f8539e7fcb8f093a56e138112056ec1dc809ebb020b59d8a36a5ebac37e0";
+  };
+  slf4j = fetchurl {
+    url = "http://central.maven.org/maven2/org/slf4j/slf4j-api/1.7.25/slf4j-api-1.7.25.jar";
+    sha256 = "18c4a0095d5c1da6b817592e767bb23d29dd2f560ad74df75ff3961dbde25b79";
+  };
 in
 
 stdenv.mkDerivation rec {
···
     in ''
       mkdir -p $out/{bin,lib,sdk}
       mv ./* $out/
+      cp ${logback-core} ${logback-classic} ${slf4j} $out/lib
 
       # Clean up documentation.
       mkdir -p $out/share/doc/${name}

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

···
 , libaio }:
 
 stdenv.mkDerivation rec {
-  name = "sysbench-1.0.15";
+  name = "sysbench-1.0.16";
 
   nativeBuildInputs = [ autoreconfHook pkgconfig ];
   buildInputs = [ vim mysql.connector-c libaio ];
···
   src = fetchFromGitHub {
     owner = "akopytov";
     repo = "sysbench";
-    rev = "1.0.15";
-    sha256 = "0ddj4mxxqlnlp817ix2qad0v3p83azi9wyz4h7mffchgp3mndp9z";
+    rev = "1.0.16";
+    sha256 = "0ypain0m1yqn7yqfb5847fdph6a6m0rn2rnqbnkxcxz5g85kv1rg";
   };
 
   meta = {

pkgs/development/tools/pipenv/default.nix

···
 with python3Packages; buildPythonApplication rec {
     name = "${pname}-${version}";
     pname = "pipenv";
-    version = "2018.11.14";
+    version = "2018.11.26";
 
     src = fetchPypi {
       inherit pname version;
-      sha256 = "1ni2cjgm04dwi8a0376nzwwy3gklqk9d0hkl8d9j760lvqshsxjz";
+      sha256 = "0ip8zsrwmhrankrix0shig9g8q2knmr7b63sh7lqa8a5x03fcwx6";
     };
 
     LC_ALL = "en_US.UTF-8";

pkgs/development/tools/pyre/default.nix

···
-{ stdenv, fetchFromGitHub, ocamlPackages, makeWrapper, writeScript
-, dune, python3, rsync, fetchpatch, buck }:
+{ stdenv, fetchFromGitHub, ocamlPackages, writeScript
+, dune, python3, rsync, buck, watchman }:
 let
   # Manually set version - the setup script requires
   # hg and git + keeping the .git directory around.
···
     substituteInPlace scripts/build-pypi-package.sh \
         --replace 'NIX_BINARY_FILE' '${pyre-bin}/bin/pyre.bin' \
         --replace 'BUILD_ROOT="$(mktemp -d)"' "BUILD_ROOT=$PWD/build"
+    for file in client/pyre.py client/commands/initialize.py client/commands/tests/initialize_test.py; do
+      substituteInPlace "$file" \
+          --replace '"watchman"' '"${watchman}/bin/watchman"'
+    done
     substituteInPlace client/buck.py \
         --replace '"buck"' '"${buck}/bin/buck"'
     substituteInPlace client/tests/buck_test.py \

pkgs/development/tools/vagrant/0004-Support-system-installed-plugins.patch

···
+From: Antonio Terceiro <[e-mail]>
+Date: Wed, 27 May 2015 09:36:17 -0300
+Subject: Support system-installed plugins
+Source: https://salsa.debian.org/ruby-team/vagrant/blob/cb672c6dc0c63f6552c5ec4d6d7d22929d353503/debian/patches/0004-Support-system-installed-plugins.patch
+
+Plugins must be installed as regular Ruby libraries, and they must
+contain /usr/share/vagrant-plugins/plugins.d/$PLUGINNAME.json with the
+following content:
+
+{
+  "${PLUGINNAME}": {
+    "ruby_version":"$(ruby -e 'puts RUBY_VERSION')",
+    "vagrant_version":"$(cat /usr/share/vagrant/version.txt)",
+    "gem_version":"",
+    "require":"",
+    "sources":[]
+  }
+}
+---
+ lib/vagrant/plugin/manager.rb    |  4 ++--
+ lib/vagrant/plugin/state_file.rb | 22 +++++++++++++++++++++-
+ 2 files changed, 23 insertions(+), 3 deletions(-)
+
+diff --git a/lib/vagrant/plugin/manager.rb b/lib/vagrant/plugin/manager.rb
+index 567347d..d9d76a0 100644
+--- a/lib/vagrant/plugin/manager.rb
++++ b/lib/vagrant/plugin/manager.rb
+@@ -18,7 +18,7 @@ module Vagrant
+ 
+       # Returns the path to the [StateFile] for system plugins.
+       def self.system_plugins_file
+-        dir = Vagrant.installer_embedded_dir
++        dir = '@system_plugin_dir@'
+         return nil if !dir
+         Pathname.new(dir).join("plugins.json")
+       end
+@@ -38,7 +38,7 @@ module Vagrant
+ 
+         system_path  = self.class.system_plugins_file
+         @system_file = nil
+-        @system_file = StateFile.new(system_path) if system_path && system_path.file?
++        @system_file = StateFile.new(system_path, true) if system_path && system_path.file?
+ 
+         @local_file = nil
+         @globalized = @localized = false
+diff --git a/lib/vagrant/plugin/state_file.rb b/lib/vagrant/plugin/state_file.rb
+index c6872d4..935d431 100644
+--- a/lib/vagrant/plugin/state_file.rb
++++ b/lib/vagrant/plugin/state_file.rb
+@@ -11,8 +11,9 @@ module Vagrant
+       # @return [Pathname] path to file
+       attr_reader :path
+ 
+-      def initialize(path)
++      def initialize(path, system = false)
+         @path = path
++        @system = system
+ 
+         @data = {}
+         if @path.exist?
+@@ -28,6 +29,21 @@ module Vagrant
+ 
+         @data["version"] ||= "1"
+         @data["installed"] ||= {}
++        load_extra_plugins
++      end
++
++      def load_extra_plugins
++        extra_plugins = Dir.glob(@path.dirname.join('plugins.d', '*.json'))
++        extra_plugins.each do |filename|
++          json = File.read(filename)
++          begin
++            plugin_data = JSON.parse(json)
++            @data["installed"].merge!(plugin_data)
++          rescue JSON::ParserError => e
++            raise Vagrant::Errors::PluginStateFileParseError,
++              path: filename, message: e.message
++          end
++        end
+       end
+ 
+       # Add a plugin that is installed to the state file.
+@@ -107,6 +123,14 @@ module Vagrant
+           f.close
+           FileUtils.mv(f.path, @path)
+         end
++      rescue Errno::EACCES
++        # Ignore permission denied against system-installed plugins; regular
++        # users are not supposed to write there.
++        raise unless @system
++      rescue Errno::EROFS
++        # Ignore read-only filesystem against system-installed plugins; regular
++        # users are not supposed to write there.
++        raise unless @system
+       end
+ 
+       protected

pkgs/development/tools/vagrant/default.nix

···
-{ lib, fetchurl, buildRubyGem, bundlerEnv, ruby, libarchive, writeText, withLibvirt ? true, libvirt, pkgconfig }:
+{ lib, fetchurl, buildRubyGem, bundlerEnv, ruby, libarchive, writeText, withLibvirt ? true}:
 
 let
   # NOTE: bumping the version and updating the hash is insufficient;
···
   dontBuild = false;
   src = fetchurl { inherit url sha256; };
 
-  buildInputs = lib.optional withLibvirt [ libvirt pkgconfig ];
-
   patches = [
     ./unofficial-installation-nowarn.patch
     ./use-system-bundler-version.patch
+    ./0004-Support-system-installed-plugins.patch
   ];
 
+  postPatch = ''
+    substituteInPlace lib/vagrant/plugin/manager.rb --subst-var-by \
+      system_plugin_dir "$out/vagrant-plugins"
+  '';
+
   # PATH additions:
   #   - libarchive: Make `bsdtar` available for extracting downloaded boxes
   postInstall = ''
     wrapProgram "$out/bin/vagrant" \
       --set GEM_PATH "${deps}/lib/ruby/gems/${ruby.version.libDir}" \
-      --prefix PATH ':' "${lib.getBin libarchive}/bin" \
-      ${lib.optionalString withLibvirt ''
-        --prefix PATH ':' "${pkgconfig}/bin" \
-        --prefix PKG_CONFIG_PATH ':' \
-          "${lib.makeSearchPath "lib/pkgconfig" [ libvirt ]}"
-      ''}
+      --prefix PATH ':' "${lib.getBin libarchive}/bin"
+
+    mkdir -p "$out/vagrant-plugins/plugins.d"
+    echo '{}' > "$out/vagrant-plugins/plugins.json"
+  '' +
+  lib.optionalString withLibvirt ''
+    substitute ${./vagrant-libvirt.json.in} $out/vagrant-plugins/plugins.d/vagrant-libvirt.json \
+      --subst-var-by ruby_version ${ruby.version} \
+      --subst-var-by vagrant_version ${version}
   '';
 
   installCheckPhase = ''

pkgs/development/tools/vagrant/gemset_libvirt.nix

···
 {
+  excon = {
+    groups = ["default"];
+    platforms = [];
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "15l9w0938c19nxmrp09n75qpmm64k12xj69h47yvxzcxcpbgnkb2";
+      type = "gem";
+    };
+    version = "0.62.0";
+  };
+  fog-core = {
+    dependencies = ["builder" "excon" "formatador"];
+    groups = ["default"];
+    platforms = [];
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "0ac25s2wv7m6av7h7vjzd2bg3srhnn5yrz3lq1xpimhnfmp82sw6";
+      type = "gem";
+    };
+    version = "1.43.0";
+  };
+  fog-json = {
+    dependencies = ["fog-core" "multi_json"];
+    groups = ["default"];
+    platforms = [];
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "1zj8llzc119zafbmfa4ai3z5s7c4vp9akfs0f9l2piyvcarmlkyx";
+      type = "gem";
+    };
+    version = "1.2.0";
+  };
+  fog-libvirt = {
+    dependencies = ["fog-core" "fog-json" "fog-xml" "json" "ruby-libvirt"];
+    groups = ["default"];
+    platforms = [];
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "0gk16gsjd51x71wla7h5jqr6x5ywpwz5l8jdv76f9mr6fp1j2bkf";
+      type = "gem";
+    };
+    version = "0.5.0";
+  };
+  fog-xml = {
+    dependencies = ["fog-core" "nokogiri"];
+    groups = ["default"];
+    platforms = [];
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "043lwdw2wsi6d55ifk0w3izi5l1d1h0alwyr3fixic7b94kc812n";
+      type = "gem";
+    };
+    version = "0.1.3";
+  };
+  formatador = {
+    groups = ["default"];
+    platforms = [];
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "1gc26phrwlmlqrmz4bagq1wd5b7g64avpx0ghxr9xdxcvmlii0l0";
+      type = "gem";
+    };
+    version = "0.2.5";
+  };
+  json = {
+    groups = ["default"];
+    platforms = [];
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "01v6jjpvh3gnq6sgllpfqahlgxzj50ailwhj9b3cd20hi2dx0vxp";
+      type = "gem";
+    };
+    version = "2.1.0";
+  };
   mini_portile2 = {
+    groups = ["default"];
+    platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "0gzfmcywp1da8nzfqsql2zqi648mfnx6qwkig3cv36n9m0yy676y";
+      sha256 = "13d32jjadpjj6d2wdhkfpsmy68zjx90p49bgf8f7nkpz86r1fr11";
       type = "gem";
     };
     version = "2.3.0";
   };
   nokogiri = {
     dependencies = ["mini_portile2"];
-      source = {
-        remotes = ["https://rubygems.org"];
-        sha256 = "0byyxrazkfm29ypcx5q4syrv126nvjnf7z6bqi01sqkv4llsi4qz";
-        type = "gem";
-      };
+    groups = ["default"];
+    platforms = [];
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "0byyxrazkfm29ypcx5q4syrv126nvjnf7z6bqi01sqkv4llsi4qz";
+      type = "gem";
+    };
     version = "1.8.5";
+  };
+  ruby-libvirt = {
+    groups = ["default"];
+    platforms = [];
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "0d754d6pgdqyq52pl9hp0x38q1vn3vf9nz4nm5gqdj5i4fw7pba6";
+      type = "gem";
+    };
+    version = "0.7.1";
+  };
+  vagrant-libvirt = {
+    dependencies = ["fog-core" "fog-libvirt" "nokogiri"];
+    groups = ["default"];
+    platforms = [];
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "1wm5yvml3sxdzpnlp4q6yhy695syy8byd1g7cxll4pmj1kwlknym";
+      type = "gem";
+    };
+    version = "0.0.45";
   };
 }

pkgs/development/tools/vagrant/vagrant-libvirt.json.in

···
+{
+  "vagrant-libvirt": {
+    "ruby_version":"@ruby_version@",
+    "vagrant_version":"@vagrant_version@",
+    "gem_version":"",
+    "require":"",
+    "sources":[]
+  }
+}

pkgs/games/bzflag/default.nix

···
 { stdenv, lib, fetchurl, pkgconfig
-, curl, SDL2, libGLU_combined, glew, ncurses, c-ares }:
+, curl, SDL2, libGLU_combined, glew, ncurses, c-ares
+, Carbon, CoreServices }:
 
 stdenv.mkDerivation rec {
   name = "${pname}-${version}";
···
   };
 
   nativeBuildInputs = [ pkgconfig ];
-  buildInputs = [ curl SDL2 libGLU_combined glew ncurses c-ares ];
+  buildInputs = [ curl SDL2 libGLU_combined glew ncurses c-ares ]
+    ++ lib.optionals stdenv.isDarwin [ Carbon CoreServices ];
 
   meta = with lib; {
     description = "Multiplayer 3D Tank game";
     homepage = https://bzflag.org/;
     license = licenses.lgpl21Plus;
-    platforms = platforms.linux;
+    platforms = platforms.unix;
     maintainers = with maintainers; [ fpletz ];
   };
 }

pkgs/games/gcompris/default.nix

···
   gst_all_1, ninja
 }:
 stdenv.mkDerivation rec {
-  version = "0.91";
+  version = "0.95";
   name = "gcompris-${version}";
 
   src = fetchurl {
     url = "http://gcompris.net/download/qt/src/gcompris-qt-${version}.tar.xz";
-    sha256 = "09h098w9q79hnzla1pcpqlnnr6dbafm4q6zmdp7wlk11ym8n9kvg";
+    sha256 = "1aaijjx2b7k1cyx59jhs64hlp1sppw1faa81qxl5lxc79vifrlrl";
   };
 
   cmakeFlags = "-DQML_BOX2D_LIBRARY=${qmlbox2d}/${qtbase.qtQmlPrefix}/Box2D.2.0";

pkgs/games/ivan/default.nix

···
 stdenv.mkDerivation rec {
 
   name = "ivan-${version}";
-  version = "054";
+  version = "055";
 
   src = fetchFromGitHub {
     owner = "Attnam";
     repo = "ivan";
     rev = "v${version}";
-    sha256 = "0ayhp9qvxsi5dsgjvy43i3lpdis883g1xn2b8l5xkwxcqfnvsfmq";
+    sha256 = "10qrwzwfzqs7f663x1cbbhisz60axcl51glxq33zaxl0jwnmma2p";
   };
 
   nativeBuildInputs = [ cmake pkgconfig ];
···
 
   hardeningDisable = ["all"];
 
-  # To store bone and high score files in ~/.ivan of the current user
-  patches = [./new.patch];
-
   # Enable wizard mode
-  cmakeFlags = ["-DCMAKE_CXX_FLAGS=-DWIZARD" "-DFORCE_HOME_AS_STATE_DIR=ON"];
+  cmakeFlags = ["-DCMAKE_CXX_FLAGS=-DWIZARD"];
 
   # Help CMake find SDL_mixer.h
   NIX_CFLAGS_COMPILE = "-I${SDL2_mixer}/include/SDL2";

pkgs/games/ivan/new.patch

···
-diff --git a/CMakeLists.txt b/CMakeLists.txt
-index 13e143e..a6f9176 100644
---- a/CMakeLists.txt
-+++ b/CMakeLists.txt
-@@ -13,10 +13,14 @@ set(CMAKE_CXX_FLAGS "-std=c++11 ${CMAKE_CXX_FLAGS}")
- add_definitions(-DIVAN_VERSION="${PROJECT_VERSION}" -DUSE_SDL)
- 
- option(BUILD_MAC_APP "Build standalone application for MacOS" OFF)
-+option(FORCE_HOME_AS_STATE_DIR "Statedir will be /.ivan/ in current user's homedir" OFF)
- 
- if(UNIX)
-   add_definitions(-DUNIX)
-   include(GNUInstallDirs)
-+  if(FORCE_HOME_AS_STATE_DIR)
-+    add_definitions(-DFORCE_HOME_AS_STATE_DIR)
-+  endif(FORCE_HOME_AS_STATE_DIR)
- 
-   if(BUILD_MAC_APP)
-     install(DIRECTORY Graphics Script Music Sound DESTINATION "ivan")
-diff --git a/Main/Source/game.cpp b/Main/Source/game.cpp
-index 323a185..012feb3 100644
---- a/Main/Source/game.cpp
-+++ b/Main/Source/game.cpp
-@@ -5191,6 +5191,9 @@ festring game::GetDataDir()
- 
- festring game::GetStateDir()
- {
-+#ifdef FORCE_HOME_AS_STATE_DIR
-+  return GetHomeDir()+"/.ivan/";
-+#endif
- #ifdef UNIX
- #ifdef MAC_APP
-   return GetHomeDir();

pkgs/games/liquidwar/default.nix

···
 { stdenv, fetchurl, xproto, libX11, libXrender
-, gmp, libGLU_combined, libjpeg, libpng
+, gmp, libjpeg, libpng
 , expat, gettext, perl, guile
 , SDL, SDL_image, SDL_mixer, SDL_ttf
 , curl, sqlite, libtool, readline
···
 
   buildInputs = [
     xproto libX11 gmp guile
-    libGLU_combined libjpeg libpng
+    libjpeg libpng
     expat gettext perl
     SDL SDL_image SDL_mixer SDL_ttf
     curl sqlite
···
 
   hardeningDisable = [ "format" ];
 
-  NIX_CFLAGS_COMPILE = "-Wno-error=deprecated-declarations";
+  NIX_CFLAGS_COMPILE =
+    "-Wno-error=deprecated-declarations" +
+    # Avoid GL_GLEXT_VERSION double definition
+    " -DNO_SDL_GLEXT"
+  ;
 
   # To avoid problems finding SDL_types.h.
   configureFlags = [ "CFLAGS=-I${SDL.dev}/include/SDL" ];

pkgs/games/openra/default.nix

···
 }:
 
 stdenv.mkDerivation rec {
-  name = "openra-${version}";
-  version = "20180923";
+  pname = "openra";
+  version = "20181215";
 
   meta = with stdenv.lib; {
     description = "Real Time Strategy game engine recreating the C&C titles";
···
     owner = "OpenRA";
     repo = "OpenRA";
     rev = "release-${version}";
-    sha256 = "1pgi3zaq9fwwdq6yh19bwxscslqgabjxkvl9bcn1a5agy4bfbqk5";
+    sha256 = "0p0izykjnz7pz02g2khp7msqa00jhjsrzk9y0g29dirmdv75qa4r";
 
     extraPostFetch = ''
       sed -i 's,curl,curl --insecure,g' $out/thirdparty/{fetch-thirdparty-deps,noget}.sh
···
 
     mkdir -p $out/bin
     makeWrapper $out/lib/openra/launch-game.sh $out/bin/openra --run "cd $out/lib/openra"
+    printf "#!/bin/sh\nexec $out/bin/openra Game.Mod=ra" > $out/bin/openra-ra
+    chmod +x $out/bin/openra-ra
+    printf "#!/bin/sh\nexec $out/bin/openra Game.Mod=cnc" > $out/bin/openra-cnc
+    chmod +x $out/bin/openra-cnc
+    printf "#!/bin/sh\nexec $out/bin/openra Game.Mod=d2k" > $out/bin/openra-d2k
+    chmod +x $out/bin/openra-d2k
   '';
 }

pkgs/games/openspades/default.nix

···
-{ stdenv, fetchurl, fetchFromGitHub, cmake, unzip, zip, file
+{ stdenv, fetchurl, fetchFromGitHub, fetchpatch, cmake, unzip, zip, file
 , curl, glew , libGL, SDL2, SDL2_image, zlib, freetype, imagemagick
 , openal , opusfile, libogg
+, Cocoa
 }:
 
 stdenv.mkDerivation rec {
···
 
   buildInputs = [
     freetype SDL2 SDL2_image libGL zlib curl glew opusfile openal libogg
+  ] ++ stdenv.lib.optionals stdenv.hostPlatform.isDarwin [
+    Cocoa
+  ];
+
+  patches = [
+    # https://github.com/yvt/openspades/pull/793 fix Darwin build
+    (fetchpatch {
+      url = "https://github.com/yvt/openspades/commit/2d13704fefc475b279337e89057b117f711a35d4.diff";
+      sha256 = "1i7rcpjzkjhbv5pp6byzrxv7sb1iamqq5k1vyqlvkbr38k2dz0rv";
+    })
   ];
 
   cmakeFlags = [
···
     description = "A compatible client of Ace of Spades 0.75";
     homepage    = "https://github.com/yvt/openspades/";
     license     = licenses.gpl3;
-    platforms   = platforms.linux;
+    platforms   = platforms.all;
   };
 }

pkgs/games/ue4demos/default.nix

···
 { stdenv, fetchurl, unzip, patchelf, xorg, openal }:
 
 let
+  urls = file:
+    [
+      # Untrusted mirrors - do not update hashes
+      "https://ludios.org/mirror/ue4demos/${file}"
+      "http://web.archive.org/web/20140824192039/http://ue4linux.raxxy.com/${file}"
+    ];
+
   buildDemo = { name, src }:
     stdenv.mkDerivation rec {
       inherit name src;
···
   tappy_chicken = buildDemo rec {
     name = "ue4demos-tappy_chicken";
     src = fetchurl {
-      url = "http://ue4linux.raxxy.com/tappy_chicken.zip";
+      urls = urls "tappy_chicken.zip";
       sha256 = "0lwhvk3lpb2r5ng2cnzk7fpjj5lwhy2sch1a8v154x1xfhfb3h4v";
     };
   };
···
   swing_ninja = buildDemo rec {
     name = "ue4demos-swing_ninja";
     src = fetchurl {
-      url = "http://ue4linux.raxxy.com/swing_ninja.zip";
+      urls = urls "swing_ninja.zip";
       sha256 = "1bmgqqk3lda5h7nnqi59jgyrsn0clr3xs0k1jclnqf9fk0m8hjcv";
     };
   };
···
   card_game = buildDemo rec {
     name = "ue4demos-card_game";
     src = fetchurl {
-      url = "http://ue4linux.raxxy.com/card_game.zip";
+      urls = urls "card_game.zip";
       sha256 = "154baqias5q7kad0c89k35jbmnmlm865sll02mi7bk1yllcckz5z";
     };
   };
···
   vehicle_game = buildDemo rec {
     name = "ue4demos-vehicle_game";
     src = fetchurl {
-      url = "http://ue4linux.raxxy.com/vehicle_game.zip";
+      urls = urls "vehicle_game.zip";
       sha256 = "03dlacf1iv7sgn7pl3sx9r6243wy8fsi2kd858syfm9slg0190bs";
     };
   };
···
   shooter_game = buildDemo rec {
     name = "ue4demos-shooter_game";
     src = fetchurl {
-      url = "http://ue4linux.raxxy.com/shooter_game.zip";
+      urls = urls "shooter_game.zip";
       sha256 = "1bk32k349iqbqk8x8jffnqq0pjiqmvrvv675xxmlvkkr8qrlhz98";
     };
   };
···
   strategy_game = buildDemo rec {
     name = "ue4demos-strategy_game";
     src = fetchurl {
-      url = "http://ue4linux.raxxy.com/strategy_game.zip";
+      urls = urls "strategy_game.zip";
       sha256 = "1p7i966v1ssm20y12g4wsccpgnky3szy19qyjlacynk7bgbk6lg7";
     };
   };
···
   black_jack = buildDemo rec {
     name = "ue4demos-black_jack";
     src = fetchurl {
-      url = "http://ue4linux.raxxy.com/black_jack.zip";
+      urls = urls "black_jack.zip";
       sha256 = "0g52wkzn5isa3az32y25yx5b56wxks97pajqwkmm6gf4qpkfksxv";
     };
   };
···
   landscape_mountains = buildDemo rec {
     name = "ue4demos-landscape_mountains";
     src = fetchurl {
-      url = "http://ue4linux.raxxy.com/landscape_mountains.zip";
+      urls = urls "landscape_mountains.zip";
       sha256 = "14jzajhs3cpydvf3ag7lpj4hkpbjpwnn3xkdvdx92fi0pcl8cwym";
     };
   };
···
   matinee_demo = buildDemo rec {
     name = "ue4demos-matinee_demo";
     src = fetchurl {
-      url = "http://ue4linux.raxxy.com/matinee_demo.zip";
+      urls = urls "matinee_demo.zip";
       sha256 = "0ib8k6fl15cxzdarar2sqq5v3g3c7p2jidkdjd00nym6cvkibb4d";
     };
   };
···
   elemental_demo = buildDemo rec {
     name = "ue4demos-elemental_demo";
     src = fetchurl {
-      url = "http://ue4linux.raxxy.com/elemental_demo.zip";
+      urls = urls "elemental_demo.zip";
       sha256 = "1v4jdsy8jvv8wgc8dx17q17xigfrya5q0nfdzw4md7fzm3bg9z0v";
     };
   };
···
   effects_cave_demo = buildDemo rec {
     name = "ue4demos-effects_cave_demo";
     src = fetchurl {
-      url = "http://ue4linux.raxxy.com/effects_cave_demo.zip";
+      urls = urls "effects_cave_demo.zip";
       sha256 = "0lvd3aaha2x9pnpkdmrzi6nf7hymr95834z3l8shygjf9kbbzsz4";
     };
   };
···
   realistic_rendering = buildDemo rec {
     name = "ue4demos-realistic_rendering";
     src = fetchurl {
-      url = "http://ue4linux.raxxy.com/realistic_rendering_demo.zip";
+      urls = urls "realistic_rendering_demo.zip";
       sha256 = "0r16nznkv475hkw5rnngqsc69ch8vh86dppyyyr9nn43dkr2110a";
     };
   };
···
   reflections_subway = buildDemo rec {
     name = "ue4demos-reflections_subway";
     src = fetchurl {
-      url = "http://ue4linux.raxxy.com/reflections_subway_demo.zip";
+      urls = urls "reflections_subway_demo.zip";
       sha256 = "0dw5sm7405gxw9iqz0vpnhdprrb4wl5i14pvzl1381k973m8bd00";
     };
   };
···
   scifi_hallway_demo = buildDemo rec {
     name = "ue4demos-scifi_hallway_demo";
     src = fetchurl {
-      url = "http://ue4linux.raxxy.com/sci-fi_hallway_demo.zip";
+      urls = urls "sci-fi_hallway_demo.zip";
       sha256 = "14qp9iwm47awn8d9j6ijh6cnds308x60xs4vi2fvz2666jlz1pq2";
     };
   };
···
   mobile_temple_demo = buildDemo rec {
     name = "ue4demos-mobile_temple_demo";
     src = fetchurl {
-      url = "http://ue4linux.raxxy.com/mobile_temple_demo.zip";
+      urls = urls "mobile_temple_demo.zip";
       sha256 = "12bz4h1b9lhmqglwsa6r8q48ijqbjdha9fql31540d01kigaka75";
     };
   };
···
   stylized_demo = buildDemo rec {
     name = "ue4demos-stylized_demo";
     src = fetchurl {
-      url = "http://ue4linux.raxxy.com/stylized_demo.zip";
+      urls = urls "stylized_demo.zip";
       sha256 = "1676ridmj8rk4y4hbdscfnnka5l636av1xxl0qwvk236kq9j7v0l";
     };
   };
···
   blueprint_examples_demo = buildDemo rec {
     name = "ue4demos-blueprint_examples_demo";
     src = fetchurl {
-      url = "http://ue4linux.raxxy.com/blueprint_examples_demo.zip";
+      urls = urls "blueprint_examples_demo.zip";
       sha256 = "076q33h2hy965fvr805hsprkpcmizf638lj2ik8k923v86b15nbv";
     };
   };

pkgs/misc/drivers/sc-controller/default.nix

···
 
 buildPythonApplication rec {
   pname = "sc-controller";
-  version = "0.4.5";
+  version = "0.4.6";
 
   src = fetchFromGitHub {
     owner  = "kozec";
     repo   = pname;
     rev    = "v${version}";
-    sha256 = "0mb9r4811rfj5rs4vrdhaf3x38iy1fvxr4sk2zg3xhvc29cdf5wv";
+    sha256 = "0527igjgc5jf60ldsrc4xv3k8gw2480pmqyp6nv5xcrm5j0ah4q5";
   };
 
   nativeBuildInputs = [ wrapGAppsHook ];

pkgs/misc/emulators/blastem/default.nix

···
     maintainers = with stdenv.lib.maintainers; [ puffnfresh ];
     license = stdenv.lib.licenses.gpl3;
     platforms = stdenv.lib.platforms.linux;
+    # Makefile:140: *** aarch64 is not a supported architecture.  Stop.
+    badPlatforms = [ "aarch64-linux" ];
   };
 }

pkgs/misc/emulators/retroarch/cores.nix

···
       cmake curl libGLU_combined pcre pkgconfig sfml miniupnpc
       gettext glib gtk2 hidapi
       libevdev udev
-    ] ++ (with xorg; [ libSM libX11 libXi libpthreadstubs libxcb xcbutil ]);
+    ] ++ (with xorg; [ libSM libX11 libXi libpthreadstubs libxcb xcbutil libXinerama libXxf86vm ]);
   }).override {
     cmakeFlags = [
         "-DLINUX_LOCAL_DEV=true"

pkgs/misc/emulators/snes9x-gtk/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "snes9x-gtk-${version}";
-  version = "1.56.2";
+  version = "1.57";
 
   src = fetchFromGitHub {
     owner = "snes9xgit";
     repo = "snes9x";
     rev = version;
-    sha256 = "0cbv95799gpagf6bxs1fmwmxvz5qs9g2rmmf5fsdd1cb4lryaijr";
+    sha256 = "1jcvj2l03b98iz6aq4x747vfz7i6h6j339z4brj4vz71s11vn31a";
   };
 
   enableParallelBuilding = true;

pkgs/misc/emulators/wine/sources.nix

···
 in rec {
 
   stable = fetchurl rec {
-    version = "3.0.3";
+    version = "3.0.4";
     url = "https://dl.winehq.org/wine/source/3.0/wine-${version}.tar.xz";
-    sha256 = "18add8wqqz7y1aj8x0dcba7pqj9jkbhngwjv4yjmar3gxacmjr7b";
+    sha256 = "037vlrk80lagy362w7500i2ldwvdwsadrknajzi67cvxpvnqhnnl";
 
     ## see http://wiki.winehq.org/Gecko
     gecko32 = fetchurl rec {
···
 
   winetricks = fetchFromGitHub rec {
     # https://github.com/Winetricks/winetricks/releases
-    version = "20180815";
-    sha256 = "0ksz2jkpqq8vnsc511zag9zcx8486hs8mwlmkkygljc8ylb1ibn5";
+    version = "20181203";
+    sha256 = "1as5h5xibpplm619b1i73g974p96q2jnd7fqm28xj3zkqy7qjdm3";
     owner = "Winetricks";
     repo = "winetricks";
     rev = version;

pkgs/misc/themes/plano/default.nix pkgs/data/themes/plano/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "plano-theme-${version}";
-  version = "3.28-3";
+  version = "3.30-2";
 
   src = fetchFromGitHub {
     owner = "lassekongo83";
     repo = "plano-theme";
     rev = "v${version}";
-    sha256 = "0k9jgnifc2s8vsw9fanknx1mg8vlh6qa1cbb910nm4vgrxsbrc74";
+    sha256 = "06yagpb0dpb8nzh3lvs607rzg6y5l6skl4mjcmbxayapsqka45hj";
   };
 
   buildInputs = [ gdk_pixbuf gtk_engines ];

pkgs/misc/themes/shades-of-gray/default.nix pkgs/data/themes/shades-of-gray/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "shades-of-gray-theme-${version}";
-  version = "1.1.1";
+  version = "1.1.3";
 
   src = fetchFromGitHub {
     owner = "WernerFP";
     repo = "Shades-of-gray-theme";
     rev = version;
-    sha256 = "1m75m6aq4hh39m8qrmbkaw31j4gzkh63ial4xnhw2habf31av682";
+    sha256 = "14p1s1pmzqnn9j9vwqfxfd4i045p356a6d9rwzzs0gx3c6ibqx3a";
   };
 
   buildInputs = [ gtk_engines ];
···
 
   installPhase = ''
     mkdir -p $out/share/themes
-    cp -a Shades-of-gray* README.md preview_01.png $out/share/themes/
+    cp -a Shades-of-gray* $out/share/themes/
   '';
 
   meta = with stdenv.lib; {

pkgs/misc/vim-plugins/generated.nix

···
     };
   };
 
+  Recover-vim = buildVimPluginFrom2Nix {
+    name = "Recover-vim-2018-10-22";
+    src = fetchFromGitHub {
+      owner = "chrisbra";
+      repo = "Recover.vim";
+      rev = "28195f7d1047515438c43a3ae8ac39648376412b";
+      sha256 = "03jd3jzq0b1djym448vyg0bvrkfrhk86djkbkyzajrsfj46ygs8q";
+    };
+  };
+
   Rename = buildVimPluginFrom2Nix {
     name = "Rename-2011-08-31";
     src = fetchFromGitHub {

pkgs/misc/vim-plugins/vim-plugin-names

···
 chikatoike/concealedyank.vim
 chikatoike/sourcemap.vim
 chrisbra/CheckAttach
+chrisbra/Recover.vim
 chrisbra/csv.vim
 chrisgeo/sparkup
 chriskempson/base16-vim

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

···
   };
 
   fuse_3 = mkFuse {
-    version = "3.3.0";
-    sha256Hash = "1pwrnfm8jkxxqhrjz0v1gaw36hshgznchyj961qdk2y697y4zp19";
+    version = "3.4.1";
+    sha256Hash = "1aihvklhqx7abqiy5n9gns7gryqgjldhzghigwrqwnwvf9z0ggyx";
   };
 }

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

···
 
 stdenv.mkDerivation rec {
   name = "fwts-${version}";
-  version = "18.11.00";
+  version = "18.12.00";
 
   src = fetchzip {
     url = "http://fwts.ubuntu.com/release/fwts-V${version}.tar.gz";
-    sha256 = "14dxw0ny5z681kz4dpm2phyanr2q4c8fqml3mhdr1mb2ndrrwqgz";
+    sha256 = "10kzn5r099i4b8m5l7s68fs885d126l9cingq9gj1g574c18hg2s";
     stripRoot = false;
   };
 
···
     substituteInPlace src/lib/include/fwts_binpaths.h --replace "/usr/sbin/dmidecode" "${dmidecode}/bin/dmidecode"
     substituteInPlace src/lib/include/fwts_binpaths.h --replace "/usr/bin/iasl"       "${iasl}/bin/iasl"
   '';
+
+  enableParallelBuilding = true;
 
   meta = with stdenv.lib; {
     homepage = "https://wiki.ubuntu.com/FirmwareTestSuite";

pkgs/os-specific/linux/kernel/common-config.nix

···
       NFS_V4_SECURITY_LABEL = yes;
 
       CIFS_XATTR        = yes;
-      CIFS_POSIX        = yes;
+      CIFS_POSIX        = option yes;
       CIFS_FSCACHE      = yes;
       CIFS_STATS        = whenOlder "4.19" yes;
       CIFS_WEAK_PW_HASH = yes;

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

···
 with stdenv.lib;
 
 buildLinux (args // rec {
-  version = "4.14.89";
+  version = "4.14.90";
 
   # 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 = "098b38518va6hhv5114vkyhyr2xzx01wxwib4dm0vpfx8jn1cvnf";
+    sha256 = "1jl6l7zi5dl1ahxj30m4wmnd05s61rxn8yfjkkc4mr45634x07hc";
   };
 } // (args.argsOverride or {}))

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

···
 with stdenv.lib;
 
 buildLinux (args // rec {
-  version = "4.19.10";
+  version = "4.19.12";
 
   # 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 = "151ync20fz8bmiw3826jznx8kd7fna85vygrfchsqgm9xk76isdg";
+    sha256 = "0xwvk6989glrpfc6irzf1lh3lvcckms72ngja9dpyqb2km9sr0ad";
   };
 } // (args.argsOverride or {}))

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

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

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

···
 { stdenv, buildPackages, fetchurl, perl, buildLinux, ... } @ args:
 
 buildLinux (args // rec {
-  version = "4.9.146";
+  version = "4.9.147";
   extraMeta.branch = "4.9";
 
   src = fetchurl {
     url = "mirror://kernel/linux/kernel/v4.x/linux-${version}.tar.xz";
-    sha256 = "0ncf7yqavxqkkwdrapy72hb7rsj67fm1rvd2hdy12p88wf5ml6aq";
+    sha256 = "10hxxcwa9lgsdz0k6229fly9r7iyqv9xq838zx8s7bd12qrrfb59";
   };
 } // (args.argsOverride or {}))

pkgs/servers/clickhouse/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "clickhouse-${version}";
-  version = "18.14.9";
+  version = "18.14.18";
 
   src = fetchFromGitHub {
     owner  = "yandex";
     repo   = "ClickHouse";
     rev    = "v${version}-stable";
-    sha256 = "1dsqwihh48fgsjy3jmfjk5271dw3052agw5wpfdm054nkkych86i";
+    sha256 = "0nivnmlnamcjxwc66ja9fagi5fqzzjsnrrfk32f4g8sxffx2rjy3";
   };
 
   nativeBuildInputs = [ cmake libtool ninja ];
···
 
   postInstall = ''
     rm -rf $out/share/clickhouse-test
+
+    sed -i -e '\!<log>/var/log/clickhouse-server/clickhouse-server\.log</log>!d' \
+      $out/etc/clickhouse-server/config.xml
+    substituteInPlace $out/etc/clickhouse-server/config.xml \
+      --replace "<errorlog>/var/log/clickhouse-server/clickhouse-server.err.log</errorlog>" "<console>1</console>"
   '';
 
   meta = with stdenv.lib; {

pkgs/servers/foundationdb/default.nix

···
 , lib, fetchurl, fetchpatch, fetchFromGitHub
 
 , which, findutils, m4, gawk
-, python, openjdk, mono58, libressl
+, python, openjdk, mono, libressl
 }:
 
 let
···
           inherit rev sha256;
         };
 
-        nativeBuildInputs = [ python openjdk gawk which m4 findutils mono58 ];
+        nativeBuildInputs = [ python openjdk gawk which m4 findutils mono ];
         buildInputs = [ libressl boost ];
 
         patches =

pkgs/servers/home-assistant/cli.nix

···
+{ lib, python3 }:
+
+python3.pkgs.buildPythonApplication rec {
+  pname = "homeassistant-cli";
+  version = "0.3.0";
+
+  src = python3.pkgs.fetchPypi {
+    inherit pname version;
+    sha256 = "42d7cb008801d7a448b62aed1fc46dd450ee67397bf16faabb02f691417db4b2";
+  };
+
+  postPatch = ''
+    # Ignore pinned versions
+    sed -i "s/'\(.*\)==.*'/'\1'/g" setup.py
+  '';
+
+  propagatedBuildInputs = with python3.pkgs; [
+    requests pyyaml netdisco click click-log tabulate idna jsonpath_rw jinja2
+  ];
+
+  checkInputs = with python3.pkgs; [
+    pytest requests-mock
+  ];
+
+  checkPhase = ''
+    pytest
+  '';
+
+  meta = with lib; {
+    description = "Command-line tool for Home Asssistant";
+    homepage = https://github.com/home-assistant/home-assistant-cli;
+    license = licenses.asl20;
+    maintainers = with maintainers; [ dotlambda ];
+  };
+}

pkgs/servers/home-assistant/component-packages.nix

···
 # Do not edit!
 
 {
-  version = "0.84.3";
+  version = "0.84.6";
   components = {
     "abode" = ps: with ps; [  ];
     "ads" = ps: with ps; [  ];

pkgs/servers/home-assistant/default.nix

···
-{ lib, fetchFromGitHub, fetchpatch, python
+{ lib, fetchFromGitHub, fetchpatch, python3
 
 # Look up dependencies of specified components in component-packages.nix
 , extraComponents ? []
···
     (mkOverride "colorlog" "3.1.4"
       "418db638c9577f37f0fae4914074f395847a728158a011be2a193ac491b9779d")
 
-    # hass-frontend does not exist in python.pkgs
+    # hass-frontend does not exist in python3.pkgs
     (self: super: {
       hass-frontend = self.callPackage ./frontend.nix { };
     })
···
       });
     };
     
-  py = python.override {
+  py = python3.override {
     # Put packageOverrides at the start so they are applied after defaultOverrides
     packageOverrides = lib.foldr lib.composeExtensions (self: super: { }) ([ packageOverrides ] ++ defaultOverrides);
   };
···
   extraBuildInputs = extraPackages py.pkgs;
 
   # Don't forget to run parse-requirements.py after updating
-  hassVersion = "0.84.3";
+  hassVersion = "0.84.6";
 
 in with py.pkgs; buildPythonApplication rec {
   pname = "homeassistant";
···
     owner = "home-assistant";
     repo = "home-assistant";
     rev = version;
-    sha256 = "0b7634niqqmcckhqb7vx1wimibfs4v042bwja7am90jy0hzafbji";
+    sha256 = "142hxsvhb9lh77h54975vkvl1fx5lslrydq1vbqyy51dy85ms8lc";
   };
 
   propagatedBuildInputs = [

pkgs/servers/home-assistant/frontend.nix

···
 
 buildPythonPackage rec {
   pname = "home-assistant-frontend";
-  version = "20181211.1";
+  version = "20181211.2";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "c3bb994e8e121d146fedc113b35ced0c007169fd70b489e9344df082f934dbdf";
+    sha256 = "75dd525922efc1f9a6a4a42c720764a539b18636769e2febc33bb68967c7ebff";
   };
 
   propagatedBuildInputs = [ user-agents ];

pkgs/servers/http/unit/default.nix

···
-{ stdenv, fetchurl
-, which
-, python
-, php71
-, php72
-, php73
-, perl
-, perldevel
-, ruby_2_3
-, ruby_2_4
-, ruby
+{ stdenv, fetchFromGitHub, which
+, withPython ? true, python
+, withPHP71 ? false, php71
+, withPHP72 ? true, php72
+, withPHP73 ? false, php73
+, withPerl ? true, perl
+, withPerldevel ? false, perldevel
+, withRuby_2_3 ? false, ruby_2_3
+, withRuby_2_4 ? false, ruby_2_4
+, withRuby ? true, ruby
 , withSSL ? true, openssl ? null
 , withIPv6 ? true
 , withDebug ? false
···
 with stdenv.lib;
 
 stdenv.mkDerivation rec {
-  version = "1.6";
+  version = "1.7";
   name = "unit-${version}";
 
-  src = fetchurl {
-    url = "https://unit.nginx.org/download/${name}.tar.gz";
-    sha256 = "0lws5xpzkcmv0gc7vi8pgnymin02dq4gw0zb41jfzq0vbljxxl14";
+  src = fetchFromGitHub {
+    owner = "nginx";
+    repo = "unit";
+    rev = "${version}";
+    sha256 = "1klwricr0mxhw5wka35vnl919821vcvaf5w3ixvkbxaisml19qq4";
   };
 
-  buildInputs = [
-    which
-    python
-    php71
-    php72
-    php73
-    perl
-    perldevel
-    ruby_2_3
-    ruby_2_4
-    ruby
-  ] ++ optional withSSL openssl;
+  nativeBuildInputs = [ which ];
+
+  buildInputs = [ ]
+    ++ optional withPython python
+    ++ optional withPHP71 php71
+    ++ optional withPHP72 php72
+    ++ optional withPHP73 php73
+    ++ optional withPerl perl
+    ++ optional withPerldevel perldevel
+    ++ optional withRuby_2_3 ruby_2_3
+    ++ optional withRuby_2_4 ruby_2_4
+    ++ optional withRuby ruby
+    ++ optional withSSL openssl;
 
   configureFlags = [
     "--control=unix:/run/control.unit.sock"
···
     ++ optional withDebug   [ "--debug" ];
 
   postConfigure = ''
-    ./configure python  --module=python    --config=${python}/bin/python-config  --lib-path=${python}/lib
-    ./configure php     --module=php71     --config=${php71.dev}/bin/php-config  --lib-path=${php71}/lib
-    ./configure php     --module=php72     --config=${php72.dev}/bin/php-config  --lib-path=${php72}/lib
-    ./configure php     --module=php73     --config=${php73.dev}/bin/php-config  --lib-path=${php73}/lib
-    ./configure perl    --module=perl      --perl=${perl}/bin/perl
-    ./configure perl    --module=perl529   --perl=${perldevel}/bin/perl
-    ./configure ruby    --module=ruby23    --ruby=${ruby_2_3}/bin/ruby
-    ./configure ruby    --module=ruby24    --ruby=${ruby_2_4}/bin/ruby
-    ./configure ruby    --module=ruby      --ruby=${ruby}/bin/ruby
+    ${optionalString withPython     "./configure python  --module=python    --config=${python}/bin/python-config  --lib-path=${python}/lib"}
+    ${optionalString withPHP71      "./configure php     --module=php71     --config=${php71.dev}/bin/php-config  --lib-path=${php71}/lib"}
+    ${optionalString withPHP72      "./configure php     --module=php72     --config=${php72.dev}/bin/php-config  --lib-path=${php72}/lib"}
+    ${optionalString withPHP73      "./configure php     --module=php73     --config=${php73.dev}/bin/php-config  --lib-path=${php73}/lib"}
+    ${optionalString withPerl       "./configure perl    --module=perl      --perl=${perl}/bin/perl"}
+    ${optionalString withPerldevel  "./configure perl    --module=perl529   --perl=${perldevel}/bin/perl"}
+    ${optionalString withRuby_2_3   "./configure ruby    --module=ruby23    --ruby=${ruby_2_3}/bin/ruby"}
+    ${optionalString withRuby_2_4   "./configure ruby    --module=ruby24    --ruby=${ruby_2_4}/bin/ruby"}
+    ${optionalString withRuby       "./configure ruby    --module=ruby      --ruby=${ruby}/bin/ruby"}
   '';
 
   meta = {

pkgs/servers/matrix-synapse/default.nix

···
 
 in buildPythonApplication rec {
   pname = "matrix-synapse";
-  version = "0.33.9";
+  version = "0.34.0";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "1wdpywqi1xd6dy3hxnnjnh2amlmhljf8s0bff9v55jyh42bj1vpn";
+    sha256 = "1bqwivzfx3kikzjmn4mng829ll8y62pd08hvsx99arr7cyzp6gri";
   };
 
   patches = [
···
     netaddr
     phonenumbers
     pillow
-    prometheus_client
+    (prometheus_client.overrideAttrs (x: {
+      src = fetchPypi {
+        pname = "prometheus_client";
+        version = "0.3.1";
+        sha256 = "093yhvz7lxl7irnmsfdnf2030lkj4gsfkg6pcmy4yr1ijk029g0p";
+      };
+    }))
     psutil
     psycopg2
     pyasn1

pkgs/servers/miniflux/default.nix

···
 }:
 
 buildGoPackage rec {
-  name = "miniflux-${version}";
-  version = "2.0.12";
+  pname = "miniflux";
+  version = "2.0.13";
 
   goPackagePath = "miniflux.app";
 
···
     owner = "miniflux";
     repo = "miniflux";
     rev = "refs/tags/${version}";
-    sha256 = "13d1dwcwig7b5phymgxqm227k5l3zzzvx997cywarbl953ji2y1d";
+    sha256 = "16c9jszrz3153kr0xyj7na09hpqvnjsrmsbic7qkp5a9aa839b9s";
   };
     
   goDeps = ./deps.nix;
···
   '';
 
   meta = with stdenv.lib; {
-    description = "Miniflux is a minimalist and opinionated feed reader.";
+    description = "Minimalist and opinionated feed reader";
     homepage = https://miniflux.app/;
     license = licenses.asl20;
     maintainers = with maintainers; [ benpye ];

pkgs/servers/nosql/aerospike/default.nix

···
     description = "Flash-optimized, in-memory, NoSQL database";
     homepage = http://aerospike.com/;
     license = licenses.agpl3;
-    #platforms = [ "x86_64-linux" ];  # breaks eval of nixos manual for aarch64
-    platforms = platforms.linux;
+    platforms = [ "x86_64-linux" ];
     maintainers = with maintainers; [ kalbasit ];
   };
 }

pkgs/servers/nosql/redis/default.nix

···
 { stdenv, fetchurl, lua }:
 
 stdenv.mkDerivation rec {
-  version = "5.0.1";
+  version = "5.0.3";
   name = "redis-${version}";
 
   src = fetchurl {
     url = "http://download.redis.io/releases/${name}.tar.gz";
-    sha256 = "1jxbjmsxn0lgh0y3k5j57rxf2sdjj71hxhw4jcvsvycpxh77r9l2";
+    sha256 = "00iyv4ybcgm5xxcm85lg1p99q7xijm05cpadlxa65chpz3fv9472";
   };
 
   buildInputs = [ lua ];

pkgs/servers/plex/default.nix

···
 let
   plexPass = throw "Plex pass has been removed at upstream's request; please unset nixpkgs.config.plex.pass";
   plexpkg = if enablePlexPass then plexPass else {
-    version = "1.14.0.5470";
-    vsnHash = "9d51fdfaa";
-    sha256 = "cf547d286c731e98b19b70954f2777653fe77c30c329faab260c460374984010";
+    version = "1.14.1.5488";
+    vsnHash = "cc260c476";
+    sha256 = "8ee806f35ccedcecd0cab028bbe1f7e2ac7de24292b715978d3165c4712f5c40";
   };
 
 in stdenv.mkDerivation rec {

pkgs/shells/zsh/zsh-completions/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "zsh-completions-${version}";
-  version = "0.29.0";
+  version = "0.30.0";
 
   src = fetchFromGitHub {
     owner = "zsh-users";
     repo = "zsh-completions";
     rev = "${version}";
-    sha256 = "0a4fdh10rhhjcy06qiyyy0xjvg7fapvy3pgif38wrjqvrddaj6pv";
+    sha256 = "1yf4rz99acdsiy0y1v3bm65xvs2m0sl92ysz0rnnrlbd5amn283l";
   };
 
   installPhase= ''

pkgs/tools/admin/nomachine-client/default.nix

···
-{ stdenv, lib, file, fetchurl, makeWrapper, autoPatchelfHook, jsoncpp }:
+{ stdenv, lib, file, fetchurl, makeWrapper,
+  autoPatchelfHook, jsoncpp, libpulseaudio }:
 let
-  versionMajor = "6.3";
+  versionMajor = "6.4";
   versionMinor = "6_1";
 in
   stdenv.mkDerivation rec {
···
       if stdenv.hostPlatform.system == "x86_64-linux" then
         fetchurl {
           url = "https://download.nomachine.com/download/${versionMajor}/Linux/nomachine_${version}_x86_64.tar.gz";
-          sha256 = "1035j2z2rqmdfb8cfm1pakd05c575640604b8lkljmilpky9mw5d";
+          sha256 = "141pv277kl5ij1pmc0iadc0hnslxri2qaqvsjkmmvls4432jh0yi";
         }
       else if stdenv.hostPlatform.system == "i686-linux" then
         fetchurl {
           url = "https://download.nomachine.com/download/${versionMajor}/Linux/nomachine_${version}_i686.tar.gz";
-          sha256 = "07j9f6mlq9m01ch8ik5dybi283vrp5dlv156jr5n7n2chzk34kf3";
+          sha256 = "0a2vi4ygw34yw8rcjhw17mqx5qbjnym4jkap8paik8lisb5mhnyj";
         }
       else
         throw "NoMachine client is not supported on ${stdenv.hostPlatform.system}";
···
     '';
   
     nativeBuildInputs = [ file makeWrapper autoPatchelfHook ];
-    buildInputs = [ jsoncpp ];
+    buildInputs = [ jsoncpp libpulseaudio ];
 
     installPhase = ''
       rm bin/nxplayer bin/nxclient
···
     postFixup = ''
       makeWrapper $out/bin/nxplayer.bin $out/bin/nxplayer --set NX_SYSTEM $out/NX
       makeWrapper $out/bin/nxclient.bin $out/bin/nxclient --set NX_SYSTEM $out/NX
+
+      # libnxcau.so needs libpulse.so.0 for audio to work, but doesn't
+      # have a DT_NEEDED entry for it.
+      patchelf --add-needed libpulse.so.0 $out/NX/lib/libnxcau.so
     '';
   
     dontBuild = true;

pkgs/tools/admin/pulumi/default.nix

···
 
 let
 
-  version = "0.16.2";
+  version = "0.16.7";
 
   # switch the dropdown to “manual” on https://pulumi.io/quickstart/install.html # TODO: update script
   pulumiArchPackage = {
     "x86_64-linux" = {
       url = "https://get.pulumi.com/releases/sdk/pulumi-v${version}-linux-x64.tar.gz";
-      sha256 = "16qgy2pj3xkf1adi3882fpsl99jwsm19111fi5vzh1xqf39sg549";
+      sha256 = "1l1cn8pk05vl7vpmhny9rlz1hj0iqclqjj1r2q12qip7f4qkgsfw";
     };
     "x86_64-darwin" = {
       url = "https://get.pulumi.com/releases/sdk/pulumi-v${version}-darwin-x64.tar.gz";
-      sha256 = "18ck9khspa0x798bdlwk8dzylbsq7s35xmla8yasd9qqlab1yy1a";
+      sha256 = "0p07jvgy0xl524fgb5d9wijxa91isv4h4mcn9qghycqj90yqnjhx";
     };
   };
 

pkgs/tools/archivers/fsarchiver/default.nix

···
+{ stdenv, fetchFromGitHub, autoreconfHook, pkgconfig
+, zlib, bzip2, lzma, lzo, lz4, zstd, xz
+, libgcrypt, e2fsprogs, utillinux, libgpgerror }:
+
+let
+  version = "0.8.5";
+
+in stdenv.mkDerivation {
+  name = "fsarchiver-${version}";
+
+  src = fetchFromGitHub {
+    owner = "fdupoux";
+    repo = "fsarchiver";
+    rev = version;
+    sha256 = "1rvwq5v3rl14bqxjm1ibfapyicf0sa44nw7451v10kx39lp56ylp";
+  };
+
+  nativeBuildInputs = [
+    autoreconfHook pkgconfig
+  ];
+
+  buildInputs = [
+    zlib bzip2 lzma lzo lz4 zstd xz
+    libgcrypt e2fsprogs utillinux libgpgerror
+  ];
+
+  meta = with stdenv.lib; {
+    description = "File system archiver for linux";
+    longDescription = ''
+      FSArchiver is a system tool that allows you to save the contents of a
+      file-system to a compressed archive file. The file-system can be restored
+      on a partition which has a different size and it can be restored on a
+      different file-system. Unlike tar/dar, FSArchiver also creates the
+      file-system when it extracts the data to partitions. Everything is
+      checksummed in the archive in order to protect the data. If the archive is
+      corrupt, you just loose the current file, not the whole archive.
+    '';
+    homepage = http://www.fsarchiver.org/;
+    license = licenses.lgpl2;
+    maintainers = [ maintainers.etu ];
+    platforms = platforms.linux;
+  };
+}

pkgs/tools/audio/abcm2ps/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "abcm2ps-${version}";
-  version = "8.14.1";
+  version = "8.14.2";
 
   src = fetchFromGitHub {
     owner = "leesavide";
     repo = "abcm2ps";
     rev = "v${version}";
-    sha256 = "1i39wfrnjflhfbqhcphr9dw08q4si5i724wv423996whk5xni61l";
+    sha256 = "15hka82zps3rfp4xdbzlf23wz4hqjk084awzfjh357qn168bwwid";
   };
 
   prePatch = ''

pkgs/tools/audio/playerctl/default.nix

···
-{ stdenv, meson, ninja, fetchFromGitHub, glib, pkgconfig, gobject-introspection }:
+{ stdenv, meson, ninja, fetchFromGitHub, glib, pkgconfig, gtk-doc, docbook_xsl, gobject-introspection }:
 
 stdenv.mkDerivation rec {
   name = "playerctl-${version}";
-  version = "0.6.1";
+  version = "2.0.1";
 
   src = fetchFromGitHub {
     owner = "acrisci";
     repo = "playerctl";
     rev = "v${version}";
-    sha256 = "0jnylj5d6i29c5y6yjxg1a88r2qfbac5pj95f2aljjkfh9428jbb";
+    sha256 = "0j1fvcc80307ybl1z9l752sr4bcza2fmb8qdivpnm4xmm82faigb";
   };
 
-  nativeBuildInputs = [ meson ninja pkgconfig gobject-introspection ];
+  nativeBuildInputs = [ meson ninja pkgconfig gtk-doc docbook_xsl gobject-introspection ];
   buildInputs = [ glib ];
-
-  # docs somehow crashes the install phase:
-  # https://github.com/acrisci/playerctl/issues/85
-  mesonFlags = [ "-Dgtk-doc=false" ];
 
   meta = with stdenv.lib; {
     description = "Command-line utility and library for controlling media players that implement MPRIS";
···
     license = licenses.lgpl3;
     platforms = platforms.unix;
     maintainers = with maintainers; [ puffnfresh ];
+    broken = stdenv.hostPlatform.isDarwin;
   };
 }

pkgs/tools/compression/mozlz4a/default.nix

···
 stdenv.mkDerivation rec {
   name = "${pname}-${version}";
   pname = "mozlz4a";
-  version = "2015-07-24";
+  version = "2018-08-23";
   # or fetchFromGitHub(owner,repo,rev) or fetchgit(rev)
   src = fetchurl {
-    url = "https://gist.githubusercontent.com/Tblue/62ff47bef7f894e92ed5/raw/2483756c55ed34be565aea269f05bd5eeb6b0a33/mozlz4a.py";
-    sha256 = "1y52zqkdyfacl2hr5adkjphgqfyfylp8ksrkh165bq48zlbf00s8";
+    url = "https://gist.githubusercontent.com/kaefer3000/73febe1eec898cd50ce4de1af79a332a/raw/a266410033455d6b4af515d7a9d34f5afd35beec/mozlz4a.py";
+    sha256 = "1d1ai062kdms34bya9dlykkx011rj8d8nh5l7d76xj8k9kv4ssq6";
   };
 
   unpackPhase = "true;";

pkgs/tools/filesystems/duperemove/default.nix

···
   nativeBuildInputs = [ pkgconfig ];
   buildInputs = [ libgcrypt glib linuxHeaders sqlite ];
 
-  makeFlags = [ "DESTDIR=$(out)" "PREFIX=" ];
+  makeFlags = [ "PREFIX=${placeholder "out"}" ];
 
   meta = with stdenv.lib; {
     description = "A simple tool for finding duplicated extents and submitting them for deduplication";

pkgs/tools/filesystems/sshfs-fuse/default.nix

···
 }:
 
 stdenv.mkDerivation rec {
-  version = "3.5.0";
+  version = "3.5.1";
   name = "sshfs-fuse-${version}";
 
   src = fetchFromGitHub {
     owner = "libfuse";
     repo = "sshfs";
     rev = "sshfs-${version}";
-    sha256 = "1mczf13ic5ycfhcxmxma50n5h32vygcll0d8m39vam237s95aqy6";
+    sha256 = "07ryavfbbzfxaswsbr8ifnnfn6g8yxgxam6mk6gvcskld6rkf6gd";
   };
 
   nativeBuildInputs = [ meson pkgconfig ninja docutils ];

pkgs/tools/misc/datamash/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "datamash-${version}";
-  version = "1.3";
+  version = "1.4";
 
   src = fetchurl {
     url = "mirror://gnu/datamash/${name}.tar.gz";
-    sha256 = "19jpcv4ryvbz0476d6dgpxpbjkpmih4q84wj06nslls338bm5fzf";
+    sha256 = "fa44dd2d5456bcb94ef49dfc6cfe62c83fd53ac435119a85d34e6812f6e6472a";
   };
 
   meta = with stdenv.lib; {

pkgs/tools/misc/hyperledger-fabric/default.nix

···
+{ stdenv, buildGoPackage, fetchFromGitHub }:
+
+buildGoPackage rec {
+  pname = "hyperledger-fabric";
+  version = "1.3.0";
+
+  goPackagePath = "github.com/hyperledger/fabric";
+
+  # taken from https://github.com/hyperledger/fabric/blob/v1.3.0/Makefile#L108
+  subPackages = [
+    "common/tools/configtxgen"
+    "common/tools/configtxlator"
+    "common/tools/cryptogen"
+    "common/tools/idemixgen"
+    "cmd/discover"
+    "peer"
+    "orderer"
+  ];
+
+  src = fetchFromGitHub {
+    owner = "hyperledger";
+    repo = "fabric";
+    rev = "v${version}";
+    sha256 = "08qrrxzgkqg9v7n3y8f2vggyqx9j65wisxi17hrabz5mzaq299xs";
+  };
+
+  doCheck = true;
+
+  meta = with stdenv.lib; {
+    description = "An implementation of blockchain technology, leveraging familiar and proven technologies";
+    homepage = https://wiki.hyperledger.org/projects/Fabric;
+    license = licenses.asl20;
+    maintainers = [ maintainers.marsam ];
+  };
+}

pkgs/tools/misc/qt5ct/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "qt5ct-${version}";
-  version = "0.36";
+  version = "0.37";
 
   src = fetchurl {
     url = "mirror://sourceforge/qt5ct/${name}.tar.bz2";
-    sha256 = "12gfhchp05xn311zsxh41k3anyrscg53r5d06dasyxyk6hpr9hwg";
+    sha256 = "0n8csvbpislxjr2s1xi8r5a4q4bqn4kylcy2zws6w7z4m8pdzrny";
   };
 
   nativeBuildInputs = [ qmake qttools ];

pkgs/tools/misc/you-get/default.nix

···
 
 buildPythonApplication rec {
   pname = "you-get";
-  version = "0.4.1181";
+  version = "0.4.1193";
 
   # Tests aren't packaged, but they all hit the real network so
   # probably aren't suitable for a build environment anyway.
···
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "1rcy590392aycjazi3z8gf6ll39rxkbgmkgnsbsl6yl5vb3jgk83";
+    sha256 = "1q7wha0d55pw077bs92bbzx6ck3nsmhnxblz7zaqzladn23hs9zg";
   };
 
   meta = with stdenv.lib; {

pkgs/tools/networking/bud/default.nix

···
     description = "A TLS terminating proxy";
     license     = licenses.mit;
     platforms   = platforms.linux;
+    # Does not build on aarch64-linux.
+    badPlatforms = [ "aarch64-linux" ];
     maintainers = with maintainers; [ cstrahan ];
   };
 }

pkgs/tools/networking/nss-pam-ldapd/default.nix

···
-{ stdenv, fetchurl, pkgconfig, openldap, python, pam, makeWrapper }:
+{ stdenv, fetchurl
+, pkgconfig, makeWrapper, autoreconfHook
+, openldap, python, pam
+}:
 
 stdenv.mkDerivation rec {
   name = "nss-pam-ldapd-${version}";
   version = "0.9.10";
-  
+
   src = fetchurl {
     url = "https://arthurdejong.org/nss-pam-ldapd/${name}.tar.gz";
     sha256 = "1cqamcr6qpgwxijlr6kg7jspjamjra8w0haan0qssn0yxn95d7c0";
   };
-  
-  nativeBuildInputs = [ pkgconfig ];
-  buildInputs = [ makeWrapper python openldap pam ];
+
+  nativeBuildInputs = [ pkgconfig makeWrapper autoreconfHook ];
+  buildInputs = [ openldap pam python ];
 
   preConfigure = ''
     substituteInPlace Makefile.in --replace "install-data-local: " "# install-data-local: "
···
     "--with-nslcd-socket=/run/nslcd/socket"
     "--with-nslcd-pidfile=/run/nslcd/nslcd.pid"
     "--with-pam-seclib-dir=$(out)/lib/security"
+    "--enable-kerberos=no"
   ];
 
   postInstall = ''

pkgs/tools/networking/strongswan/default.nix

···
 , curl
 , enableTNC            ? false, trousers, sqlite, libxml2
 , enableNetworkManager ? false, networkmanager
+, libpcap
 }:
 
 # Note on curl support: If curl is built with gnutls as its backend, the
···
     [ curl gmp python iptables ldns unbound openssl pcsclite ]
     ++ optionals enableTNC [ trousers sqlite libxml2 ]
     ++ optionals stdenv.isLinux [ systemd.dev pam ]
-    ++ optionals enableNetworkManager [ networkmanager ];
+    ++ optionals enableNetworkManager [ networkmanager ]
+    # ad-hoc fix for https://github.com/NixOS/nixpkgs/pull/51787
+    # Remove when the above PR lands in master
+    ++ [ libpcap ];
 
   patches = [
     ./ext_auth-path.patch

pkgs/tools/networking/tgt/default.nix

···
 
   buildInputs = [ libxslt systemd libaio docbook_xsl ];
 
-  DESTDIR = "$(out)";
-  PREFIX = "/";
-  SD_NOTIFY="1";
+  makeFlags = [
+    "PREFIX=${placeholder "out"}"
+    "SD_NOTIFY=1"
+  ];
+
+  installFlags = [
+    "sysconfdir=${placeholder "out"}/etc"
+  ];
 
   preConfigure = ''
     sed -i 's|/usr/bin/||' doc/Makefile

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

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

pkgs/tools/package-management/cde/default.nix

···
     license = licenses.gpl3;
     maintainers = [ maintainers.rlupton20 ];
     platforms = platforms.linux;
+    # error: architecture aarch64 is not supported by strace
+    badPlatforms = [ "aarch64-linux" ];
   };
 }

pkgs/tools/package-management/nix-review/default.nix

···
 
 python3.pkgs.buildPythonApplication rec {
   pname = "nix-review";
-  version = "1.0.1";
+  version = "1.0.2";
 
   src = fetchFromGitHub {
     owner = "Mic92";
     repo = "nix-review";
     rev = version;
-    sha256 = "18z7dws3ngx0ffqqgybq65xxsiycildd101q58sj51z1k3lnrynh";
+    sha256 = "0vgar8sb2471zipxa1cw0n90mrnn5da7wqdlxhamnkrylbh0mc0d";
   };
 
   makeWrapperArgs = [

pkgs/tools/security/b2sum/default.nix

···
     homepage = "https://blake2.net";
     license = with licenses; [ asl20 cc0 openssl ];
     maintainers = with maintainers; [ kirelagin ];
-    platforms = platforms.all;
+    # "This code requires at least SSE2."
+    platforms = with platforms; [ "x86_64-linux" "i686-linux" ] ++ darwin;
   };
 }

pkgs/tools/security/monkeysphere/default.nix

···
 , perl, libassuan, libgcrypt
 , perlPackages, lockfileProgs, gnupg, coreutils
 # For the tests:
-, bash, openssh, which, socat, cpio, hexdump
+, bash, openssh, which, socat, cpio, hexdump, openssl
 }:
 
-stdenv.mkDerivation rec {
+let
+  # A patch is needed to run the tests inside the Nix sandbox:
+  # /etc/passwd: "nixbld:x:1000:100:Nix build user:/build:/noshell"
+  # sshd: "User nixbld not allowed because shell /noshell does not exist"
+  opensshUnsafe = openssh.overrideAttrs (oldAttrs: {
+    patches = oldAttrs.patches ++ [ ./openssh-nixos-sandbox.patch ];
+  });
+in stdenv.mkDerivation rec {
   name = "monkeysphere-${version}";
   version = "0.42";
+
+  # The patched OpenSSH binary MUST NOT be used (except in the check phase):
+  disallowedRequisites = [ opensshUnsafe ];
 
   src = fetchurl {
     url = "http://archive.monkeysphere.info/debian/pool/monkeysphere/m/monkeysphere/monkeysphere_${version}.orig.tar.gz";
···
   nativeBuildInputs = [ makeWrapper ];
   buildInputs = [ perl libassuan libgcrypt ]
     ++ stdenv.lib.optional doCheck
-      ([ gnupg openssh which socat cpio hexdump lockfileProgs ] ++
+      ([ gnupg opensshUnsafe which socat cpio hexdump lockfileProgs ] ++
       (with perlPackages; [ CryptOpenSSLRSA CryptOpenSSLBignum ]));
 
   makeFlags = ''
···
     DESTDIR=$(out)
   '';
 
-  # The tests "drain" entropy (GnuPG still uses /dev/random) and they don't run
-  # inside of the sandbox, because nixbld isn't allowed to login via SSH
-  # (/etc/passwd: "nixbld:x:1000:100:Nix build user:/build:/noshell",
-  # sshd: "User nixbld not allowed because shell /noshell does not exist").
+  # The tests should be run (and succeed) when making changes to this package
+  # but they aren't enabled by default because they "drain" entropy (GnuPG
+  # still uses /dev/random).
   doCheck = false;
-  preCheck = ''
+  preCheck = stdenv.lib.optionalString doCheck ''
     patchShebangs tests/
     patchShebangs src/
-    sed -i "s,/usr/sbin/sshd,${openssh}/bin/sshd," tests/basic
+    sed -i \
+      -e "s,/usr/sbin/sshd,${opensshUnsafe}/bin/sshd," \
+      -e "s,/bin/true,${coreutils}/bin/true," \
+      -e "s,/bin/false,${coreutils}/bin/false," \
+      -e "s,openssl\ req,${openssl}/bin/openssl req," \
+      tests/basic
     sed -i "s/<(hd/<(hexdump/" tests/keytrans
   '';
 

pkgs/tools/security/monkeysphere/openssh-nixos-sandbox.patch

···
+diff --git a/auth.c b/auth.c
+index d2a8cd65..811a129f 100644
+--- a/auth.c
++++ b/auth.c
+@@ -580,6 +580,12 @@ getpwnamallow(const char *user)
+ #endif
+ 
+ 	pw = getpwnam(user);
++        if (pw != NULL) {
++		// This is only for testing purposes,
++		// DO NOT USE THIS PATCH IN PRODUCTION!
++		char *shell = "/bin/sh";
++		pw->pw_shell = shell;
++        }
+ 
+ #if defined(_AIX) && defined(HAVE_SETAUTHDB)
+ 	aix_restoreauthdb();

pkgs/tools/security/neopg/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "neopg-${version}";
-  version = "0.0.5";
+  version = "0.0.4";
 
   src = fetchFromGitHub {
     owner = "das-labor";
     repo = "neopg";
     rev = "v${version}";
-    sha256 = "1ky3pwg6w8kyaa9iksfx6rryva87mbj1h3yi2mrzp2h7jhrfffpp";
+    sha256 = "0hhkl326ff6f76k8pwggpzmivbm13fz497nlyy6ybn5bmi9xfblm";
     fetchSubmodules = true;
   };
 

pkgs/tools/security/vault/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "vault-${version}";
-  version = "1.0.0";
+  version = "1.0.1";
 
   src = fetchFromGitHub {
     owner = "hashicorp";
     repo = "vault";
     rev = "v${version}";
-    sha256 = "0wqqf9mif6icfl888w2izvml7vqs4hkd5hrq4dhzcyig5w1bp0if";
+    sha256 = "17gyl8hb72gwb3vy7nrp3cj9lrj0zgb8xja0bgwqpv511hg1qwwf";
   };
 
   nativeBuildInputs = [ go gox removeReferencesTo ];

pkgs/tools/system/collectd/default.nix

···
 { stdenv, fetchurl, fetchpatch, darwin
-# optional:
-, pkgconfig ? null  # most of the extra deps need pkgconfig to be found
-, curl ? null
-, iptables ? null
-, jdk ? null
-, libatasmart ? null
-, libcredis ? null
-, libdbi ? null
-, libgcrypt ? null
-, libmemcached ? null, cyrus_sasl ? null
-, libmicrohttpd ? null
-, libmodbus ? null
-, libnotify ? null, gdk_pixbuf ? null
-, liboping ? null
-, libpcap ? null
-, libsigrok ? null
-, libvirt ? null
-, libxml2 ? null
-, libtool ? null
-, lm_sensors ? null
-, lvm2 ? null
-, mysql ? null
-, postgresql ? null
-, protobufc ? null
-, python ? null
-, rabbitmq-c ? null
-, riemann_c_client ? null
-, rrdtool ? null
-, udev ? null
-, varnish ? null
-, yajl ? null
-, net_snmp ? null
-, hiredis ? null
-, libmnl ? null
-, mosquitto ? null
-, rdkafka ? null
-, mongoc ? null
+, autoreconfHook
+, pkgconfig
+, curl
+, iptables
+, jdk
+, libapparmor
+, libatasmart
+, libcap_ng
+, libcredis
+, libdbi
+, libgcrypt
+, libmemcached, cyrus_sasl
+, libmicrohttpd
+, libmodbus
+, libnotify, gdk_pixbuf
+, liboping
+, libpcap
+, libsigrok
+, libvirt
+, libxml2
+, libtool
+, lm_sensors
+, lvm2
+, mysql
+, numactl
+, postgresql
+, protobufc
+, python
+, rabbitmq-c
+, riemann_c_client
+, rrdtool
+, udev
+, varnish
+, yajl
+, net_snmp
+, hiredis
+, libmnl
+, mosquitto
+, rdkafka
+, mongoc
 }:
 stdenv.mkDerivation rec {
   version = "5.8.1";
···
     sha256 = "1njk8hh56gb755xafsh7ahmqr9k2d4lam4ddj7s7fqz0gjigv5p7";
   };
 
-  # on 5.8.0: lvm2app.h:21:2: error: #warning "liblvm2app is deprecated, use D-Bus API instead." [-Werror=cpp]
-  NIX_CFLAGS_COMPILE = [ "-Wno-error=cpp" ];
+  patches = [
+    (fetchpatch {
+      url = "https://github.com/rpv-tomsk/collectd/commit/d5a3c020d33cc33ee8049f54c7b4dffcd123bf83.patch";
+      sha256 = "1n65zw4d2k2bxapayaaw51ym7hy72a0cwi2abd8jgxcw3d0m5g15";
+    })
+  ];
 
-  nativeBuildInputs = [ pkgconfig ];
+  nativeBuildInputs = [ pkgconfig autoreconfHook ];
   buildInputs = [
     curl libdbi libgcrypt libmemcached
     cyrus_sasl libnotify gdk_pixbuf liboping libpcap libvirt
···
   ] ++ stdenv.lib.optionals stdenv.isLinux [
     iptables libatasmart libcredis libmodbus libsigrok
     lm_sensors lvm2 rabbitmq-c udev net_snmp libmnl
+    # those might be no longer required when https://github.com/NixOS/nixpkgs/pull/51767
+    # is merged
+    libapparmor numactl libcap_ng
   ] ++ stdenv.lib.optionals stdenv.isDarwin [
     darwin.apple_sdk.frameworks.IOKit
     darwin.apple_sdk.frameworks.ApplicationServices
   ];
 
-  configureFlags = [ "--localstatedir=/var" ];
+  configureFlags = [
+    "--localstatedir=/var"
+    "--disable-werror"
+  ];
 
   # do not create directories in /var during installPhase
   postConfigure = ''

pkgs/tools/system/localtime/default.nix

···
-{ stdenv, go, systemd, polkit, fetchFromGitHub, m4, removeReferencesTo }:
+{ stdenv, systemd, polkit, fetchFromGitHub, buildGoPackage, m4}:
 
-stdenv.mkDerivation {
+buildGoPackage rec {
   name = "localtime-2017-11-07";
 
   src = fetchFromGitHub {
···
     rev = "2e7b4317c723406bd75b2a1d640219ab9f8090ce";
     sha256 = "04fyna8p7q7skzx9fzmncd6gx7x5pwa9jh8a84hpljlvj0kldfs8";
   };
+  goPackagePath = "github.com/Stebalien/localtime";
 
-  buildInputs = [ go systemd polkit m4 removeReferencesTo ];
-  disallowedRequisites = [ go ];
+  buildInputs = [ systemd polkit m4 ];
 
   makeFlags = [ "PREFIX=$(out)" ];
 
-  preFixup = ''
-    find $out/bin -type f -exec remove-references-to -t ${go} '{}' +
+  buildPhase = ''
+    cd go/src/${goPackagePath}
+    make localtimed
+  '';
+
+  installPhase = ''
+    mkdir -p $bin/bin
+    install -Dm555 localtimed $bin/bin
   '';
 
   meta = with stdenv.lib; {

pkgs/tools/system/syslog-ng/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "${pname}-${version}";
-  version = "3.18.1";
+  version = "3.19.1";
 
   src = fetchurl {
     url = "https://github.com/balabit/${pname}/releases/download/${name}/${name}.tar.gz";
-    sha256 = "1y1v16vvyirh0qv4wzczqp8d3llh6dl63lz3irwib1qhh7x56dyn";
+    sha256 = "0y2ixmbl4af4yf0a56pmg1c00nh0yvlfwr9ck9nhxbdysylk3yaw";
   };
 
   nativeBuildInputs = [ pkgconfig which ];

pkgs/tools/video/bento4/default.nix

···
   meta = with stdenv.lib; {
     description = "Full-featured MP4 format and MPEG DASH library and tools";
     homepage = http://bento4.com;
-    license = licenses.gpl3;
+    license = licenses.gpl2Plus;
     maintainers = with maintainers; [ makefu ];
     broken = stdenv.isAarch64;
     platforms = platforms.linux;

pkgs/tools/virtualization/google-compute-engine-oslogin/default.nix

···
+{ stdenv
+, fetchFromGitHub
+, curl
+, json_c
+, pam
+}:
+
+stdenv.mkDerivation rec {
+  name = "google-compute-engine-oslogin-${version}";
+  version = "1.4.3";
+
+  src = fetchFromGitHub {
+    repo = "compute-image-packages";
+    owner = "GoogleCloudPlatform";
+    rev = "2ccfe80f162a01b5b7c3316ca37981fc8b3fc32a";
+    sha256 = "036g7609ni164rmm68pzi47vrywfz2rcv0ad67gqf331pvlr92x1";
+  };
+  sourceRoot = "source/google_compute_engine_oslogin";
+
+  postPatch = ''
+    # change sudoers dir from /var/google-sudoers.d to /run/google-sudoers.d (managed through systemd-tmpfiles)
+    substituteInPlace pam_module/pam_oslogin_admin.cc --replace /var/google-sudoers.d /run/google-sudoers.d
+    # fix "User foo not allowed because shell /bin/bash does not exist"
+    substituteInPlace utils/oslogin_utils.cc --replace /bin/bash /bin/sh
+  '';
+
+  buildInputs = [ curl.dev pam ];
+
+  NIX_CFLAGS_COMPILE="-I${json_c.dev}/include/json-c";
+  NIX_CFLAGS_LINK="-L${json_c}/lib";
+
+  installPhase = ''
+    mkdir -p $out/{bin,lib}
+
+    install -Dm755 libnss_cache_google-compute-engine-oslogin-${version}.so $out/lib/libnss_cache_oslogin.so.2
+    install -Dm755 libnss_google-compute-engine-oslogin-${version}.so $out/lib/libnss_oslogin.so.2
+
+    install -Dm755 pam_oslogin_admin.so pam_oslogin_login.so $out/lib
+    install -Dm755 google_{oslogin_nss_cache,authorized_keys} $out/bin
+  '';
+
+  meta = with stdenv.lib; {
+    homepage = https://github.com/GoogleCloudPlatform/compute-image-packages;
+    description = "OS Login Guest Environment for Google Compute Engine";
+    license = licenses.asl20;
+    maintainers = with maintainers; [ adisbladis flokli ];
+  };
+}

pkgs/top-level/aliases.nix

···
   terraform-provider-ibm = terraform-providers.ibm; # added 2018-09-28
   terraform-provider-libvirt = terraform-providers.libvirt; # added 2018-09-28
   terraform-provider-nixos = terraform-providers.nixos; # added 2018-09-28
+  tesseract_4 = tesseract4; # added 2018-12-19
   tex-gyre-bonum-math = tex-gyre-math.bonum; # added 2018-04-03
   tex-gyre-pagella-math = tex-gyre-math.pagella; # added 2018-04-03
   tex-gyre-schola-math = tex-gyre-math.schola; # added 2018-04-03

pkgs/top-level/all-packages.nix

···
 
   fileshelter = callPackage ../servers/web-apps/fileshelter { };
 
+  firecracker = callPackage ../applications/virtualization/firecracker { };
+
   fsmon = callPackage ../tools/misc/fsmon { };
 
   fsql = callPackage ../tools/misc/fsql { };
···
 
   dropbear = callPackage ../tools/networking/dropbear { };
 
+  dsview = libsForQt5.callPackage ../applications/science/electronics/dsview { };
+
   dtach = callPackage ../tools/misc/dtach { };
 
   dtc = callPackage ../development/compilers/dtc { };
···
 
   ftop = callPackage ../os-specific/linux/ftop { };
 
+  fsarchiver = callPackage ../tools/archivers/fsarchiver { };
+
   fsfs = callPackage ../tools/filesystems/fsfs { };
 
   fstl = qt5.callPackage ../applications/graphics/fstl { };
···
 
   google-compute-engine = python2.pkgs.google-compute-engine;
 
+  google-compute-engine-oslogin = callPackage ../tools/virtualization/google-compute-engine-oslogin { };
+
   gource = callPackage ../applications/version-management/gource { };
 
   govc = callPackage ../tools/virtualization/govc { };
···
 
   jaaa = callPackage ../applications/audio/jaaa { };
 
-  jackett = callPackage ../servers/jackett {
-    mono = mono514;
-  };
+  jackett = callPackage ../servers/jackett { };
 
   jade = callPackage ../tools/text/sgml/jade { };
 
···
   libcmis = callPackage ../development/libraries/libcmis { };
 
   libee = callPackage ../development/libraries/libee { };
+
+  libepc = callPackage ../development/libraries/libepc { };
 
   libestr = callPackage ../development/libraries/libestr { };
 
···
   adoptopenjdk-openj9-bin-11 = if stdenv.isLinux
     then callPackage adoptopenjdk-bin-11-packages-linux.jdk-openj9 {}
     else callPackage adoptopenjdk-bin-11-packages-darwin.jdk-openj9 {};
-  adoptopenjdk-jre-openj9-bin-11 = if stdenv.isLinux
-    then callPackage adoptopenjdk-bin-11-packages-linux.jre-openj9 {}
-    else callPackage adoptopenjdk-bin-11-packages-darwin.jre-openj9 {};
+
+  # openj9 jre builds for mac are currently missing (upstream)
+  #adoptopenjdk-jre-openj9-bin-11 = if stdenv.isLinux
+  #  then callPackage adoptopenjdk-bin-11-packages-linux.jre-openj9 {}
+  #  else callPackage adoptopenjdk-bin-11-packages-darwin.jre-openj9 {};
+  adoptopenjdk-jre-openj9-bin-11 = callPackage adoptopenjdk-bin-11-packages-linux.jre-openj9 {};
 
   adoptopenjdk-bin = adoptopenjdk-hotspot-bin-11;
   adoptopenjdk-jre-bin = adoptopenjdk-jre-hotspot-bin-11;
···
 
   fsharp = callPackage ../development/compilers/fsharp { };
 
-  fsharp41 = callPackage ../development/compilers/fsharp41 {
-    mono = mono46;
-  };
+  fsharp41 = callPackage ../development/compilers/fsharp41 { mono = mono4; };
 
   fstar = callPackage ../development/compilers/fstar { };
 
···
           ((openjdk11.override { minimal = true; }) // {}));
 
   jdk = jdk8;
-  jre = jre8;
+  jre = if stdenv.isAarch32 || stdenv.isAarch64 then adoptopenjdk-jre-bin else jre8;
   jre_headless = jre8_headless;
 
   inherit (callPackages ../development/compilers/graalvm { }) mx jvmci8 graalvm8;
···
 
   mlton = mlton20180207;
 
-  mono  = mono5;
-  mono5 = mono58;
-  mono4 = mono48;
+  mono = mono5;
 
-  mono46 = lowPrio (callPackage ../development/compilers/mono/4.6.nix {
+  mono4 = lowPrio (callPackage ../development/compilers/mono/4.nix {
     inherit (darwin) libobjc;
     inherit (darwin.apple_sdk.frameworks) Foundation;
   });
 
-  mono48 = lowPrio (callPackage ../development/compilers/mono/4.8.nix {
-    inherit (darwin) libobjc;
-    inherit (darwin.apple_sdk.frameworks) Foundation;
-  });
-
-  mono50 = lowPrio (callPackage ../development/compilers/mono/5.0.nix {
-    inherit (darwin) libobjc;
-    inherit (darwin.apple_sdk.frameworks) Foundation;
-  });
-
-  mono54 = lowPrio (callPackage ../development/compilers/mono/5.4.nix {
-    inherit (darwin) libobjc;
-    inherit (darwin.apple_sdk.frameworks) Foundation;
-  });
-
-  mono58 = callPackage ../development/compilers/mono/5.8.nix {
-    inherit (darwin) libobjc;
-    inherit (darwin.apple_sdk.frameworks) Foundation;
-  };
-
-  mono514 = callPackage ../development/compilers/mono/5.14.nix {
+  mono5 = callPackage ../development/compilers/mono/5.nix {
     inherit (darwin) libobjc;
     inherit (darwin.apple_sdk.frameworks) Foundation;
   };
···
   urweb = callPackage ../development/compilers/urweb { };
 
   inherit (callPackage ../development/compilers/vala { })
-    vala_0_34
     vala_0_36
     vala_0_38
     vala_0_40
···
   python = python2;
   python2 = python27;
   python3 = python37;
-  pypy = pypy27;
+  pypy = pypy2;
+  pypy2 = pypy27;
 
   # Python interpreter that is build with all modules, including tkinter.
   # These are for compatibility and should not be used inside Nixpkgs.
···
     python = python27.override{x11Support=true;};
     db = db.override { dbmSupport = true; };
   };
+  pypy3 = callPackage ../development/interpreters/python/pypy/3 {
+    self = pypy3;
+    python = python27;
+    db = db.override { dbmSupport = true; };
+  };
 
   # Python package sets.
   python27Packages = lib.hiPrioSet (recurseIntoAttrs python27.pkgs);
···
   python36Packages = python36.pkgs;
   python37Packages = recurseIntoAttrs python37.pkgs;
   pypyPackages = pypy.pkgs;
+  pypy2Packages = pypy2.pkgs;
+  pypy27Packages = pypy27.pkgs;
+  pypy3Packages = pypy3.pkgs;
 
   update-python-libraries = callPackage ../development/interpreters/python/update-python-libraries { };
 
···
 
   libsigrokdecode = callPackage ../development/tools/libsigrokdecode { };
 
+  # special forks used for dsview
+  libsigrok4dsl = callPackage ../applications/science/electronics/dsview/libsigrok4dsl.nix { };
+  libsigrokdecode4dsl = callPackage ../applications/science/electronics/dsview/libsigrokdecode4dsl.nix { };
+
   dcadec = callPackage ../development/tools/dcadec { };
 
   dejagnu = callPackage ../development/tools/misc/dejagnu { };
···
 
   goocanvas = callPackage ../development/libraries/goocanvas { };
   goocanvas2 = callPackage ../development/libraries/goocanvas/2.x.nix { };
+  goocanvasmm2 = callPackage ../development/libraries/goocanvasmm { };
 
   google-gflags = callPackage ../development/libraries/google-gflags { };
   gflags = google-gflags; # TODO: move to aliases.nix
···
 
   gtksourceviewmm = callPackage ../development/libraries/gtksourceviewmm { };
 
+  gtksourceviewmm4 = callPackage ../development/libraries/gtksourceviewmm/4.x.nix { };
+
   gtkspell2 = callPackage ../development/libraries/gtkspell { };
 
   gtkspell3 = callPackage ../development/libraries/gtkspell/3.nix { };
···
   } // (stdenv.lib.optionalAttrs (stdenv.cc.isGNU && stdenv.hostPlatform.isi686) {
       stdenv = overrideCC stdenv gcc6; # with gcc-7: undefined reference to `__divmoddi4'
     }));
+  icu63 = callPackage ../development/libraries/icu/63.nix ({
+    nativeBuildRoot = buildPackages.icu63.override { buildRootOnly = true; };
+  } // (stdenv.lib.optionalAttrs (stdenv.cc.isGNU && stdenv.hostPlatform.isi686) {
+      stdenv = overrideCC stdenv gcc6; # with gcc-7: undefined reference to `__divmoddi4'
+    }));
 
   icu = icu59;
 
···
   kerberos = libkrb5; # TODO: move to aliases.nix
 
   languageMachines = recurseIntoAttrs (import ../development/libraries/languagemachines/packages.nix { inherit callPackage; });
+
+  lasem = callPackage ../development/libraries/lasem { };
 
   lasso = callPackage ../development/libraries/lasso { };
 
···
   libgap = callPackage ../development/libraries/libgap { };
 
   libgda = callPackage ../development/libraries/libgda { };
+
+  libgdamm = callPackage ../development/libraries/libgdamm { };
 
   libgdata = gnome3.libgdata;
 
···
     qmltermwidget = callPackage ../development/libraries/qmltermwidget {
       inherit (darwin.apple_sdk.libs) utmp;
     };
-    qmlbox2d = libsForQt59.callPackage ../development/libraries/qmlbox2d { };
+    qmlbox2d = libsForQt5.callPackage ../development/libraries/qmlbox2d { };
 
     qscintilla = callPackage ../development/libraries/qscintilla {
       withQt5 = true;
···
   elasticmq = callPackage ../servers/elasticmq { };
 
   eventstore = callPackage ../servers/nosql/eventstore {
-    mono = mono46;
+    mono = mono4;
     v8 = v8_6_x;
   };
 
···
 
   hiawatha = callPackage ../servers/http/hiawatha {};
 
-  home-assistant = callPackage ../servers/home-assistant {
-    python = python36;
-  };
+  home-assistant = callPackage ../servers/home-assistant { };
+
+  home-assistant-cli = callPackage ../servers/home-assistant/cli.nix { };
 
   hydron = callPackage ../servers/hydron { };
 
···
 
   penna = callPackage ../data/fonts/penna { };
 
+  plano-theme = callPackage ../data/themes/plano { };
+
   plata-theme = callPackage ../data/themes/plata {};
 
   poly = callPackage ../data/fonts/poly { };
···
   seshat = callPackage ../data/fonts/seshat { };
 
   shaderc = callPackage ../development/compilers/shaderc { };
+
+  shades-of-gray-theme = callPackage ../data/themes/shades-of-gray { };
 
   mime-types = callPackage ../data/misc/mime-types { };
 
···
   inherit (gnome3) evince;
   evolution-data-server = gnome3.evolution-data-server;
 
-  keepass = callPackage ../applications/misc/keepass {
-    buildDotnetPackage = buildDotnetPackage.override { mono = mono54; };
-  };
+  keepass = callPackage ../applications/misc/keepass { };
 
   keepass-keeagent = callPackage ../applications/misc/keepass-plugins/keeagent { };
 
···
     extra-packages = [ csound ];
   };
 
+  hyperledger-fabric = callPackage ../tools/misc/hyperledger-fabric { };
+
   jackline = callPackage ../applications/networking/instant-messengers/jackline { };
 
   slack = callPackage ../applications/networking/instant-messengers/slack { };
···
 
   linuxsampler = callPackage ../applications/audio/linuxsampler { };
 
-  llpp = ocaml-ng.ocamlPackages_4_04.callPackage ../applications/misc/llpp { };
+  llpp = ocaml-ng.ocamlPackages_4_07.callPackage ../applications/misc/llpp { };
 
   lmms = libsForQt5.callPackage ../applications/audio/lmms {
     lame = null;
···
   normalize = callPackage ../applications/audio/normalize { };
 
   mm = callPackage ../applications/networking/instant-messengers/mm { };
+
+  mm-common = callPackage ../development/libraries/mm-common { };
 
   matrique = libsForQt5.callPackage ../applications/networking/instant-messengers/matrique { };
 
···
 
   termtosvg = callPackage ../tools/misc/termtosvg { };
 
-  tesseract = callPackage ../applications/graphics/tesseract { };
-  tesseract_4 = lowPrio (callPackage ../applications/graphics/tesseract/4.x.nix { });
+  inherit (callPackage ../applications/graphics/tesseract {})
+    tesseract3
+    tesseract4;
+  tesseract = tesseract3;
 
   tetraproc = callPackage ../applications/audio/tetraproc { };
 
···
 
   btanks = callPackage ../games/btanks { };
 
-  bzflag = callPackage ../games/bzflag { };
+  bzflag = callPackage ../games/bzflag {
+    inherit (darwin.apple_sdk.frameworks) Carbon CoreServices;
+  };
 
   cataclysm-dda = callPackage ../games/cataclysm-dda {
     inherit (darwin.apple_sdk.frameworks) Cocoa;
···
 
   gcs = callPackage ../games/gcs { };
 
-  gcompris = libsForQt59.callPackage ../games/gcompris { };
+  gcompris = libsForQt5.callPackage ../games/gcompris { };
 
   gemrb = callPackage ../games/gemrb { };
 
···
 
   openrw = callPackage ../games/openrw { };
 
-  openspades = callPackage ../games/openspades { };
+  openspades = callPackage ../games/openspades {
+    inherit (darwin.apple_sdk.frameworks) Cocoa;
+  };
 
   openttd = callPackage ../games/openttd {
     zlib = zlib.override {
···
 
   ginac = callPackage ../applications/science/math/ginac { };
 
+  glom = callPackage ../applications/misc/glom { };
+
   glucose = callPackage ../applications/science/logic/glucose { };
   glucose-syrup = callPackage ../applications/science/logic/glucose/syrup.nix { };
 
···
   physlock = callPackage ../misc/screensavers/physlock { };
 
   pjsip = callPackage ../applications/networking/pjsip { };
-
-  plano-theme = callPackage ../misc/themes/plano { };
 
   ppsspp = libsForQt5.callPackage ../misc/emulators/ppsspp { };
 
···
     libsemanage = libsemanage.override { python = python3; };
   };
 
-  shades-of-gray-theme = callPackage ../misc/themes/shades-of-gray { };
-
   sierra-gtk-theme = callPackage ../misc/themes/sierra { };
 
   slock = callPackage ../misc/screensavers/slock {
···
   smokeping = callPackage ../tools/networking/smokeping { };
 
   snapraid = callPackage ../tools/filesystems/snapraid { };
+
+  snscrape = with python3Packages; toPythonApplication snscrape;
 
   soundOfSorting = callPackage ../misc/sound-of-sorting { };
 
···
   check-uptime = callPackage ../servers/monitoring/plugins/uptime.nix { };
 
   ghc-standalone-archive = callPackage ../os-specific/darwin/ghc-standalone-archive { inherit (darwin) cctools; };
+
+  vdr = callPackage ../applications/video/vdr { };
+  vdrPlugins = vdr.plugins // (recurseIntoAttrs (callPackages ../applications/video/vdr/plugins.nix { }));
+  wrapVdr = callPackage ../applications/video/vdr/wrapper.nix {};
 
   chrome-gnome-shell = callPackage  ../desktops/gnome-3/extensions/chrome-gnome-shell {};
 

pkgs/top-level/ocaml-packages.nix

···
       then callPackage ../development/ocaml-modules/csv { }
       else callPackage ../development/ocaml-modules/csv/1.5.nix { };
 
+    csv-lwt = callPackage ../development/ocaml-modules/csv/lwt.nix { };
+
     curses = callPackage ../development/ocaml-modules/curses { };
 
     custom_printf = callPackage ../development/ocaml-modules/custom_printf { };

pkgs/top-level/php-packages.nix

···
 
   phpcs = pkgs.stdenv.mkDerivation rec {
     name = "phpcs-${version}";
-    version = "3.3.2";
+    version = "3.4.0";
 
     src = pkgs.fetchurl {
       url = "https://github.com/squizlabs/PHP_CodeSniffer/releases/download/${version}/phpcs.phar";
-      sha256 = "0np3bsj32mwyrcccw5pgypz7wchd5l89bq951w9a7bxh80gjhak9";
+      sha256 = "1d6zf0ab76r5ibb80q46silhy87hrwh50gfvhd0i25wzad7r09mw";
     };
 
     phases = [ "installPhase" ];
···
 
   phpcbf = pkgs.stdenv.mkDerivation rec {
     name = "phpcbf-${version}";
-    version = "3.3.2";
+    version = "3.4.0";
 
     src = pkgs.fetchurl {
       url = "https://github.com/squizlabs/PHP_CodeSniffer/releases/download/${version}/phpcbf.phar";
-      sha256 = "1qxcd7lkqrfjibkrqq1f5szrcjmd6682mwaxha7v93pj9f92wgn4";
+      sha256 = "0iscs4hg1msk8198pmkdmbxn1g53gbq3i5qgszs0bi6hz3ng9ag9";
     };
 
     phases = [ "installPhase" ];

pkgs/top-level/python-packages.nix

···
   isPy35 = python.pythonVersion == "3.5";
   isPy36 = python.pythonVersion == "3.6";
   isPy37 = python.pythonVersion == "3.7";
-  isPyPy = python.executable == "pypy";
+  isPyPy = strings.substring 0 4 python.executable == "pypy";
   isPy3k = strings.substring 0 1 python.pythonVersion == "3";
 
   callPackage = pkgs.newScope self;
···
   fido2 = callPackage ../development/python-modules/fido2 {  };
 
   filterpy = callPackage ../development/python-modules/filterpy { };
+
+  fints = callPackage ../development/python-modules/fints { };
 
   fire = callPackage ../development/python-modules/fire { };
 
···
   seekpath = callPackage ../development/python-modules/seekpath { };
 
   selectors2 = callPackage ../development/python-modules/selectors2 { };
+
+  sepaxml = callPackage ../development/python-modules/sepaxml { };
 
   serversyncstorage = callPackage ../development/python-modules/serversyncstorage {};
 
···
   jupyterlab_server = callPackage ../development/python-modules/jupyterlab_server { };
 
   jupyterlab = callPackage ../development/python-modules/jupyterlab {};
+
+  jupytext = callPackage ../development/python-modules/jupytext { };
 
   PyLTI = callPackage ../development/python-modules/pylti { };
 
···
   django_tagging = callPackage ../development/python-modules/django_tagging { };
 
   django_tagging_0_4_3 = if
-       self.django.version != "1.8.18"
+       self.django.version != "1.8.19"
   then throw "django_tagging_0_4_3 should be build with django_1_8"
   else (callPackage ../development/python-modules/django_tagging {}).overrideAttrs (attrs: rec {
     pname = "django-tagging";
···
 
   pythonnet = callPackage ../development/python-modules/pythonnet {
     # `mono >= 4.6` required to prevent crashes encountered with earlier versions.
-    mono = pkgs.mono46;
+    mono = pkgs.mono4;
   };
 
   pytz = callPackage ../development/python-modules/pytz { };
···
   slimit = callPackage ../development/python-modules/slimit { };
 
   snowballstemmer = callPackage ../development/python-modules/snowballstemmer { };
+
+  snscrape = callPackage ../development/python-modules/snscrape { };
 
   snug = callPackage ../development/python-modules/snug { };
 
···
   unittest2 = callPackage ../development/python-modules/unittest2 { };
 
   unittest-xml-reporting = callPackage ../development/python-modules/unittest-xml-reporting { };
-
-  uritemplate_py = callPackage ../development/python-modules/uritemplate_py { };
 
   traceback2 = callPackage ../development/python-modules/traceback2 { };