miga-base 0.7.26.0 → 0.7.26.1

data/utils/enveomics/Scripts/FastA.sample.rb

@@ -0,0 +1,83 @@
+#!/usr/bin/env ruby
+
+#
+# @author Luis M. Rodriguez-R <lmrodriguezr at gmail dot com>
+# @license Artistic-2.0
+#
+
+require 'optparse'
+
+o = {q: false, rep: false}
+ARGV << '-h' if ARGV.size==0
+
+OptionParser.new do |opt|
+  opt.banner = "
+Samples a random set of sequences from a multi-FastA file.
+
+Usage: #{$0} [options]"
+  opt.separator ''
+  opt.separator 'Mandatory'
+  opt.on('-i', '--in PATH', 'Input FastA file.'){ |v| o[:i] = v }
+  opt.on('-o', '--out PATH', 'Output FastA file.'){ |v| o[:o] = v }
+  opt.on('-f', '--fraction FLOAT',
+    'Fraction of sequences to sample [0-1].',
+    'Mandatory unless -n is provided.'){ |v| o[:f] = v.to_f }
+  opt.separator ''
+  opt.separator 'Options'
+  opt.on('-c', '--number INT',
+    'Number of sequences to sample.',
+    'Mandatory unless -f is provided.'){ |v| o[:n] = v.to_i }
+  opt.on('-r', '--replacement','Sample with replacement'){ |v| o[:rep] = v }
+  opt.on('-q', '--quiet', 'Run quietly (no STDERR output).'){ o[:q] = true }
+  opt.on('-h', '--help', 'Display this screen.') do
+    puts opt
+    exit
+  end
+  opt.separator ''
+end.parse!
+abort '-i is mandatory.' if o[:i].nil?
+abort '-o is mandatory.' if o[:o].nil?
+abort '-f or -n is mandatory.' if o[:f].nil? and o[:n].nil?
+
+# Functions to parse sequences
+def do_stuff(id, sq)
+  return if id.nil? or sq.empty?
+  @n_in += 1
+  sq.gsub!(/[^A-Za-z]/, '')
+  i = 0
+  @coll.extract(id, sq).each do |new_sq|
+    @ofh.puts ">#{id}:#{i += 1}"
+    @ofh.puts new_sq
+    @n_out += 1
+  end
+end
+
+# Parse sequences
+$stderr.puts 'Parsing sequences' unless o[:q]
+seq = []
+File.open(o[:i], 'r') do |fh|
+  id = nil
+  sq = ''
+  fh.each do |ln|
+    next if ln =~ /^;/
+    if ln =~ /^>(.+)/
+      seq << [id, sq] unless id.nil?
+      id = $1
+      sq = ''
+    else
+      sq << ln
+    end
+  end
+  seq << [id, sq] unless id.nil?
+end
+$stderr.puts "  Input sequences: #{seq.size}"
+o[:n] ||= (seq.size * o[:f]).round
+seq_o = o[:rep] ? o[:n].times.map{ seq.sample } : seq.sample(o[:n])
+File.open(o[:o], 'w') do |fh|
+  seq_o.each do |i|
+    fh.puts ">#{i[0]}"
+    fh.puts i[1]
+  end
+end
+$stderr.puts "  Output sequences: #{seq_o.size}"
+

data/utils/enveomics/Scripts/FastA.slider.pl

@@ -0,0 +1,85 @@
+#!/usr/bin/env perl
+#
+# @author  Luis M. Rodriguez-R <lmrodriguezr at gmail dot com>
+# @update  Oct-07-2015
+# @license artistic license 2.0
+# 
+
+use strict;
+use List::Util qw/min/;
+
+push @ARGV, undef unless $#ARGV%2;
+my %params = @ARGV;
+
+die "
+Usage:
+   $0 [options] < in.fa > out.fa
+
+   in.fa	Input file in FastA format.
+   out.fa	Output file in FastA format.
+
+Options:
+   -seq <str>	Input file.  If not set, it is expected to be in STDIN.
+   -out <str>	Output file.  If not set, it is sent to STDOUT.
+   -win <int>	Window size.  By default: 18.
+   -step <int>	Step size.  By default: 1.
+   -lerr <int>	Expected error in chunks length.  By default: 2.
+   -comm <1|0>	Generate FastA comments (leaded by semi-colon) to separate
+		input sequences.  By default: 0.
+   -short <1|0>	Use chunks shorter than the window size 'as is'. By
+		default: 0 (discard those chunks).
+   -h		Displays this help message and exits.
+
+" if exists $params{'--help'} or
+   exists $params{'-h'} or exists $params{'-help'};
+
+if($params{'-seq'}){
+   open SEQ, "<", $params{'-seq'} or
+      die "I can not open '".$params{'-seq'}."': $!\n";
+}else{
+   *SEQ = *STDIN;
+   print STDERR "Please input your sequence, and hit ".
+      "Intro and Ctrl+D when you are done:\n";
+}
+
+if($params{'-out'}){
+   open OUT, ">", $params{'-out'} or
+      die "I can not open '".$params{'-out'}."': $!\n";
+}else{
+   *OUT = *STDOUT;
+}
+
+$params{'-win'} ||= 18;
+$params{'-step'} ||= 1;
+$params{'-lerr'} ||= 2;
+$params{'-comm'} ||= 0;
+$params{'-short'} ||= 0;
+
+my $win = $params{'-win'}+0;
+my $stp = $params{'-step'}+0;
+my $lerr = $params{'-lerr'}+0;
+my $buffer = "";
+my $i = 0;
+while(<SEQ>){
+   next if /^;/;
+   chomp;
+   if(m/^>/){
+      print OUT ">", ++$i, "\n", $buffer, "\n" if
+	 $params{'-short'}==1 and $buffer;
+      $buffer = "";
+      print OUT ";--- INPUT: $_ ---\n" unless $params{'-comm'}==0;
+      next;
+   }
+   s/[^A-Za-z]//g;
+   $buffer.= $_;
+   while(length($buffer) >= $win){
+      print OUT ">", ++$i, "\n",
+	 substr($buffer, 0, $win+int(rand($lerr*2)-$lerr)), "\n";
+      $buffer = substr $buffer, $stp;
+   }
+}
+close SEQ if $params{'-seq'};
+close OUT if $params{'-out'};
+print STDERR "$i chunks produced.\n";
+
+

data/utils/enveomics/Scripts/FastA.split.pl

@@ -0,0 +1,55 @@
+#!/usr/bin/env perl
+#
+# @author Luis M. Rodriguez-R <lmrodriguezr at gmail dot com>
+# @update Oct-13-2015
+# @license artistic license 2.0
+#
+
+use warnings;
+use strict;
+use Symbol;
+
+my ($file, $base, $outN) = @ARGV;
+
+$outN ||= 12;
+($file and $base) or die "
+Usage
+   $0 in_file.fa out_base[ no_files]
+   
+   in_file.fa	Input file in FastA format.
+   out_base	Prefix for the name of the output files.  It will
+   		be appended with .<i>.fa, where <i> is a consecutive
+		number starting in 1.
+   no_files	Number of files to generate.  By default: 12.
+
+";
+
+
+my @outSym = ();
+for my $i (1 .. $outN){
+   $outSym[$i-1] = gensym;
+   open $outSym[$i-1], ">", "$base.$i.fa" or
+      die "I can not create the file: $base.$i.fa: $!\n";
+}
+
+
+my($i, $seq) = (-1, '');
+open FILE, "<", $file or die "I can not read the file: $file: $!\n";
+while(my $ln=<FILE>){
+   next if $ln=~/^;/;
+   if($ln =~ m/^>/){
+      print { $outSym[$i % $outN] } $seq if $seq;
+      $i++;
+      $seq = '';
+   }
+   $seq.=$ln;
+}
+print { $outSym[$i % $outN] } $seq if $seq;
+close FILE;
+
+for(my $j=0; $j<$outN; $j++){
+   close $outSym[$j];
+}
+
+print STDERR "Sequences: ".($i+1)."\nFiles: $outN\n";
+

data/utils/enveomics/Scripts/FastA.split.rb

@@ -0,0 +1,79 @@
+#!/usr/bin/env ruby
+#
+# @author Luis M. Rodriguez-R <lmrodriguezr at gmail dot com>
+# @license Artistic-2.0
+#
+
+require "optparse"
+
+o = {q:false, n:12, lett:false, dc:false, z:false, out:"%s.%s.fa"}
+ARGV << "-h" if ARGV.size==0
+
+OptionParser.new do |opt|
+  opt.banner = "
+  Evenly splits a multi-FastA file into multiple multi-FastA files.
+  
+  Usage: #{$0} [options]"
+  opt.separator ""
+  opt.separator "Mandatory"
+  opt.on("-i", "--input PATH", "Input FastA file."){ |v| o[:i] = v}
+  opt.on("-p", "--prefix PATH", "Prefix of output FastA files."){ |v| o[:p] = v}
+  opt.separator ""
+  opt.separator "Options"
+  opt.on("-n", "--number INT",
+    "Number of output files to produce. By default: #{o[:n]}."
+    ){ |v| o[:n] = v.to_i }
+  opt.on("-z", "--zero-padded",
+    "Use zero-padded numbers as output index."){ o[:lett]=false; o[:z]=true }
+  opt.on("-l", "--lowercase-letters",
+    "Use lowercase letters as output index."){ o[:lett]=true ; o[:dc]=true }
+    opt.on("-u", "--uppercase-letters",
+    "Use uppercase letters as output index."){ o[:lett]=true }
+  opt.on("-o", "--out STR",
+    "Format of output filenames, where %s are replaced by prefix and index.",
+    "By default: #{o[:out]}."){ |v| o[:out] = v }
+  opt.on("-q", "--quiet", "Run quietly (no STDERR output)."){ o[:q] = TRUE }
+  opt.on("-h", "--help", "Display this screen.") do
+    puts opt
+    exit
+  end
+  opt.separator ""
+end.parse!
+abort "-i is mandatory." if o[:i].nil?
+abort "-p is mandatory." if o[:p].nil?
+
+ofh = []
+idx = if o[:lett]
+  k = Math::log(o[:n], 26).ceil
+  r = o[:dc] ? ["a","z"] : ["A","Z"]
+  ((r[0]*k) .. (r[1]*k)).first(o[:n])
+elsif o[:z]
+  k = Math::log(o[:n], 10).ceil
+  (1 .. o[:n]).map{ |i| "%0#{k}d" % i }
+else
+  (1 .. o[:n]).map{ |i| i.to_s }
+end
+idx.each do |i|
+  fn = o[:out] % [o[:p], i]
+  ofh << File.open(fn, "w")
+end
+
+i = -1
+seq = ""
+File.open(o[:i], "r") do |ifh|
+  ifh.each_line do |ln|
+    next if ln =~ /^;/
+    if ln =~ /^>/
+      ofh[i % o[:n]].print seq
+      i += 1
+      seq = ""
+    end
+    seq << ln
+  end
+  ofh[i % o[:n]].print seq
+end
+
+ofh.each{ |i| i.close }
+
+$stderr.puts "Sequences: #{i+1}.", "Files: #{o[:n]}." unless o[:q]
+

data/utils/enveomics/Scripts/FastA.subsample.pl

@@ -0,0 +1,131 @@
+#!/usr/bin/env perl
+# 
+# @author  Luis M. Rodriguez-R <lmrodriguezr at gmail dot com>
+# @update  Oct-07-2015
+# @license artistic license 2.0
+# 
+
+use strict;
+use warnings;
+use List::Util qw| max min sum |;
+use Getopt::Std;
+use Symbol;
+
+my %o;
+getopts('f:r:o:Fzhq', \%o);
+
+my $HELP = <<HELP
+
+  Description:
+    Subsamples a set of sequences.
+
+  Usage:
+    # IMPORTANT: options *MUST* precede the input file(s).
+    $0 [options] input.fa...
+  
+  Where,
+    input.fa...	: File (or files) containing the sequences.
+  
+  Options:
+    -f <float>	: Fraction of the library to be sampled (as percentage).  It can
+    		  include several values (separated by comma), as well as ranges
+		  of values in the form 'from-to/by'.  For example, the -f value
+		  1-5/1,10-50/10,75,99 will produce 12 subsamples with expected
+		  fractions 1%, 2%, 3%, 4%, 5%, 10%, 20%, 30%, 40%, 50%, 75%,
+		  and 99%.  By default: 10.
+    -r <int>	: Number of replicates per fraction.  By default: 1.
+    -o <str>	: Prefix of the output files to be created.  The output files
+		  will have a suffix of the form '.fraction-replicate.fa', where
+		  'fraction' is the percentage sampled and 'replicate' is an
+		  increasing integer for replicates of the same fraction.  By
+		  default: Path to the input file.
+    -F		: Force overwriting output file(s).
+    -z		: Include leading zeroes in the numeric parts of the output
+    		  files (e.g., file.002.50-01.fa instead of file.2.50-1.fa), so
+		  that alphabetic sorting of files reflects the sampled
+		  fraction.
+    -q		: Run quietly.
+    -h		: Displays this message and exits.
+
+HELP
+;
+
+sub thousands($){ my $i=shift; $i=~s/(\d{1,3}?)(?=(\d{3})+$)/$1,/g; $i }
+my @in  = @ARGV;
+$o{f} ||= '10';
+$o{r} ||= 1;
+$o{o} ||= $in[0];
+$#in>=0 or die $HELP;
+
+my $samples = {};
+my $sample_no=0;
+my $format = ($o{z} ? "%s\.%08s\-%02i.fa" : "%s.%s-%s.fa");
+for my $value (split /,/, $o{f}){
+   my $from = $value;
+   my $to   = $value;
+   my $by   = 1;
+   if($value =~ m/^([^-]+)-([^\/]+)\/(.+)$/){
+      $from = $1;
+      $to   = $2;
+      $by   = $3;
+      ($from,$to) = ($to,$from) if $from > $to;
+   }
+   for(my $p=$from; $p<=$to; $p+=$by){
+      die "Percentage out of the [0,100] range: $p\n" if $p>100 or $p<0;
+      $samples->{$p} ||= [];
+      for (1 .. $o{r}){
+         my $r = $#{$samples->{$p}}+2;
+         my $file = sprintf $format, $o{o}, sprintf("%.4f", $p), $r;
+	 die "File exists: $file.\n" if !$o{F} and -e $file;
+	 $samples->{$p}->[$r-1] = [$p, 0, gensym(), $file];
+	 open $samples->{$p}->[$r-1]->[2], ">", $file;
+	 $sample_no++;
+      }
+   }
+}
+print STDERR "Open samples: $sample_no.\n" unless $o{q};
+
+my $sprob = ($o{s} || '10');
+
+die $HELP unless $sprob and $#in>=0;
+$o{'h'} and die $HELP;
+
+my $N  = 0;
+my @ck = qw(*... **.. ***. .*** ..** ...*);
+SAMPLING: {
+   local $/ = "\n>";
+   print STDERR "Sampling sequences.\n" unless $o{q};
+   FILE: for my $in (@in){
+      open IN, '<', $in or die "I can not open $in: $!\n";
+      SEQ: while(my $seq = <IN>){
+	 $N++;
+	 $seq =~ s/^>?/>/;
+	 $seq =~ s/>$//;
+	 $seq =~ s/^;.*//gm;
+	 PERC: for my $sperc (values %$samples){
+	    SAMPLE: for my $sample (@$sperc){
+	       if($sample->[0] > rand 100){
+		  $sample->[1]++;
+		  print { qualify_to_ref $sample->[2] } $seq;
+	       }
+	    }
+	 }
+	 print STDERR " [".$ck[($N/5000)%@ck]."] ".&thousands($N).
+	    " seqs.    \r" unless $o{q} or $N%5000;
+      }
+      close IN;
+   }
+}
+
+print STDERR "  Total sequences: ".&thousands($N).".    \n" unless $o{q};
+for my $p (values %$samples){
+   for my $s (@$p){
+      printf STDERR "
+      Sample file:       %s
+      Sampled sequences: %d
+      Sampled fraction:  %.2f%%\n",
+      $s->[3], $s->[1], $s->[1]*100/$N unless $o{q};
+      close $s->[2];
+   }
+}
+

data/utils/enveomics/Scripts/FastA.tag.rb

@@ -0,0 +1,65 @@
+#!/usr/bin/env ruby
+
+# @author  Luis M. Rodriguez-R
+# @license artistic license 2.0
+
+require 'optparse'
+
+o = {q: false, p: '', s: '', d: false}
+ARGV << '-h' if ARGV.size==0
+OptionParser.new do |opts|
+  opts.banner = "
+Generates easy-to-parse tagged reads from FastA files.
+
+Usage: #{$0} [options]"
+  opts.separator ''
+  opts.separator 'Mandatory'
+  opts.on('-i', '--in FILE',
+    'Path to the FastA file containing the sequences.'){ |v| o[:in] = v }
+  opts.on('-o', '--out FILE',
+    'Path to the FastA to create.'){ |v| o[:out] = v }
+  opts.separator ''
+  opts.separator 'ID options'
+  opts.on('-p', '--prefix STR', 'Prefix to use in all IDs.'){ |v| o[:p] = v }
+  opts.on('-s', '--suffix STR', 'Suffix to use in all IDs.'){ |v| o[:s] = v }
+  opts.on('-d', '--defline',
+    'Keep the original defline after a space.'){ o[:d] = true }
+  opts.on('-l', '--list FILE',
+    'Reads a list of IDS.'){ |v| o[:l] = v }
+  opts.separator ''
+  opts.separator 'Other Options'
+  opts.on('-q', '--quiet', 'Run quietly (no STDERR output)'){ o[:q] = true }
+  opts.on('-h', '--help', 'Display this screen') do
+    puts opts
+    exit
+  end
+  opts.separator ''
+end.parse!
+abort '-i is mandatory' if o[:in].nil?
+abort '-o is mandatory' if o[:out].nil?
+   
+begin
+  list = o[:l].nil? ? nil :
+    File.readlines(o[:l]).map{ |i| i.chomp.gsub(/^>/, '') }
+  ofh = File.open(o[:out], 'w')
+  i = 0
+  File.open(o[:in], 'r') do |ifh|
+    ifh.each do |ln|
+      ln.chomp!
+      next if ln =~ /^;/
+      unless /^>/.match(ln).nil?
+        i += 1
+        new_id = o[:l].nil? ? i : list.shift
+        ofh.puts ">#{o[:p]}#{new_id}#{o[:s]}#{o[:d]?" #{ln[1, ln.size-1]}":''}"
+      else
+        ofh.puts ln
+      end
+    end
+  end
+  ofh.close
+rescue => err
+  $stderr.puts "Exception: #{err}\n\n"
+  err.backtrace.each { |l| $stderr.puts l + "\n" }
+  err
+end
+