blob: 36dbe44183cb1e1c6e38016ba8718a8be1e5ac41 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
|
{nixpkgs ? import <nixpkgs> {}}:
let
inherit (nixpkgs) fetchurl callPackage;
bionix = nixpkgs.lib.makeExtensible (self:
let callBionix = file: attrs: import file ({ bionix = self; } // attrs);
in with self; {
callBionix = callBionix;
id = x: x;
exec = f: x: y: f x y;
exec' = f: exec (_: f) {};
callBionixE = p: exec (callBionix p);
types = callBionix ./lib/types.nix {};
bowtie = callBionix ./tools/bowtie.nix {};
bwa = callBionix ./tools/bwa.nix {};
cnvkit = callBionix ./tools/cnvkit.nix {};
compression = callBionix ./tools/compression.nix {};
crumble = callBionix ./tools/crumble.nix {};
facets = callBionix ./tools/facets.nix {};
fastqc = callBionix ./tools/fastqc.nix {};
gridss = callBionix ./tools/gridss.nix {};
infercnv = callBionix ./tools/infercnv.nix {};
kallisto = callBionix ./tools/kallisto.nix {};
mosdepth = callBionix ./tools/mosdepth.nix {};
mutect = callBionix ./tools/mutect.nix {};
minimap2 = callBionix ./tools/minimap2.nix {};
picard = callBionix ./tools/picard.nix {};
platypus = callBionix ./tools/platypus.nix {};
ref = callBionix ./lib/references.nix {};
samtools = callBionix ./tools/samtools.nix {};
snap = callBionix ./tools/snap.nix {};
snpeff = callBionix ./tools/snpeff.nix {};
strelka = callBionix ./tools/strelka.nix {};
ascat = callBionix ./tools/ascat.nix {};
fastp = callBionix ./tools/fastp.nix {};
octopus = callBionix ./tools/octopus.nix {};
slurm = attrs: bionix.extend (self: super: with self; rec {
slurmDefs = { ppn = 1; mem = 1; walltime = "24:00:00"; partition = null; slurmFlags = null; salloc = "/usr/bin/salloc"; srun = "/usr/bin/srun"; } // attrs;
slurm = attrs: (callPackage ./lib/slurm.nix {}) (slurmDefs // attrs);
exec = f: x: y: slurm (builtins.intersectAttrs slurmDefs x) (super.exec f (builtins.removeAttrs x (builtins.attrNames slurmDefs)) y);
});
qsub = attrs: bionix.extend (self: super: with self; rec {
qsubDefs = { ppn = 1; mem = 1; walltime = "24:00:00"; tmpDir = "/tmp"; sleepTime = 60; queue = null; qsubFlags = null; qsubPath = "/usr/bin"; } // attrs;
qsub = attrs: (callPackage ./lib/qsub.nix {}) (qsubDefs // attrs);
exec = f: x: y: qsub (builtins.intersectAttrs qsubDefs x) (super.exec (builtins.removeAttrs x (builtins.attrNames qsubDefs)) y);
});
def = f: defs: attrs: f (defs // attrs);
pipe = let g = fs: with builtins; let h = head fs; t = tail fs; in if t != [] then x: (g t (h x)) else h; in g;
linkOutputs = x: with lib; nixpkgs.stdenvNoCC.mkDerivation {
name = "link-outputs";
outputs = [ "out" ] ++ attrNames x;
nativeBuildInputs = [ pkgs.perl ];
buildCommand = let
recurse = x: if x ? type && x.type == "derivation" then x else
if builtins.typeOf x == "set" then linkOutputs x
else error "linkOutputs: unsupported type";
link = dst: src: ''
ln -s ${recurse src} $(perl -e 'print $ENV{"${dst}"}') ; ln -s ${recurse src} $out/${dst}
'';
in "mkdir $out \n" + (concatStringsSep "\n" (mapAttrsToList link x));
};
# Fetching files of specific type
fetchFastQ = attrs: with types; tagFiletype (filetype.fq {}) (fetchurl attrs);
fetchFastA = attrs: with types; tagFiletype (filetype.fa {}) (fetchurl attrs);
fetchFastQGZ = attrs: with types; tagFiletype (filetype.gz (filetype.fq {})) (fetchurl attrs);
fetchFastAGZ = attrs: with types; tagFiletype (filetype.gz (filetype.fa {})) (fetchurl attrs);
# Turn a multi-output derivation into a list of derivations
outputDrvs = drv: map (o: lib.getAttr o drv) drv.outputs;
# Export nixpkgs and standard library lib
pkgs = nixpkgs;
lib = nixpkgs.lib // { types = types; shard = callBionix ./lib/shard.nix {};};
stage = x@{ name, stripStorePaths ? true, multicore ? false, ... }:
(if stripStorePaths then strip else x: x) (nixpkgs.stdenvNoCC.mkDerivation (x // {name = "bionix-" + name; inherit multicore;}));
strip = drv: let
stripCommand = ''
function rewrite {
sed -i 's|/nix/store/[^-]*|/nix/store/00000000000000000000000000000000|g' $1
}
function rewriteOutput {
if [ -f ''${!1} ] ; then
rewrite ''${!1}
else
for f in $(find ''${!1} -type f) ; do
rewrite $f
done
fi
}
for o in $outputs ; do
rewriteOutput $o
done
'';
in drv.overrideAttrs (attrs:
if attrs ? buildCommand then
{buildCommand = attrs.buildCommand + stripCommand;}
else
{ fixupPhase = (if attrs ? fixupPhase then attrs.fixupPhase else "") + stripCommand; }
);
# splitting/joining
splitFile = file: drv: stage {
name = "split-${file}";
buildCommand = "ln -s ${drv}/${file} $out";
};
split = drv: lib.mapAttrs (p: _: splitFile p drv) (builtins.readDir drv);
join = drvs: stage {
name = "join";
buildCommand = ''
mkdir $out
${builtins.concatStringsSep "\n" (builtins.attrValues (lib.mapAttrs (n: d: "ln -s ${d} $out/${n}") drvs))}
'';
};
each = f: drv: join (lib.mapAttrs (_: f) (split drv));
});
in bionix
|
