miga-base 0.3.0.0 → 0.3.0.1

data/utils/enveomics/Scripts/CharTable.classify.rb

@@ -0,0 +1,234 @@
+#!/usr/bin/env ruby
+
+#
+# @author  Luis M. Rodriguez-R
+# @update  Jan-13-2016
+# @license artistic license 2.0
+#
+
+require "optparse"
+
+o = {:q=>false}
+ARGV << "-h" if ARGV.size==0
+OptionParser.new do |opts|
+   opts.banner = "
+Uses a dichotomous key to classify objects parsing a character table.
+
+Usage: #{$0} [options]"
+   opts.separator ""
+   opts.separator "Input Options (mandatory)"
+   opts.on("-t", "--table FILE",
+      "Input table containing the states (columns) per object (row).",
+      "It must be tab-delimited and with row and column names.",
+      "See Tests/anthrax-cansnp-data.tsv for an example."){ |v| o[:table]=v }
+   opts.on("-k", "--key FILE",
+      "Input table containing the dychotomous key in linked style, defined in",
+      "four columns (can contain #-lead comment lines):",
+      "  1. ID of the step, typically a sequential integer.",
+      "  2. Name of character to evaluate. Must coincide with the -t headers.",
+      "  3. First character decision (see below).",
+      "  4. Second character decision (see below).",
+      "A character decision must be formated as: state (must coincide with the",
+      "values in -t), colon (:), step to follow. If the state is * (star) any",
+      "state triggers the decision (this should be the norm in column 4). The",
+      "step to follow should be a step ID in square brackets, or the name of",
+      "the classification. See Tests/anthrax-cansnp-key.tsv for an example."
+      ){ |v| o[:key]=v }
+   opts.separator ""
+   opts.separator "Output Options"
+   opts.on("-c", "--classification FILE",
+      "Two-column table with the classification of the input objects."
+      ){ |v| o[:class]=v }
+   opts.on("-n", "--newick FILE",
+      "Tree containing all the classified objects. This only makes sense for",
+      "synoptic keys."){ |v| o[:nwk]=v }
+   opts.separator ""
+   opts.separator "Additional 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 "-t is mandatory" if o[:table].nil?
+abort "-k is mandatory" if o[:key].nil?
+
+##### Extensions:
+class String
+   def nwk_sanitize() self.gsub(/[\(\):;,"'\s]/,'_') ; end
+end
+
+##### Classes:
+module Dychotomous
+   class Decision
+      attr_reader :state, :terminal, :conclusion
+      def initialize(string)
+	 r = string.split /:/
+	 @state = r[0]
+	 @terminal = !(r[1] =~ /^\[(.*)\]$/)
+	 @conclusion = @terminal ? r[1] : $1
+      end
+      def ==(state)
+         return true if self.state == '*'
+	 self.state == state.to_s
+      end
+   end
+   class Character
+      attr_reader :name, :a, :b
+      def initialize(name, a, b)
+	 @name = name
+	 @a = a
+	 @b = b
+      end
+      def eval(object)
+	 state = object.state(self.name)
+	 return self.a if self.a == state
+	 return self.b if self.b == state
+	 raise "Impossible to make a decision for #{object.name} based on " +
+	    "character #{self.name}. Offending state: #{state.to_s}."
+      end
+   end
+   class Key
+      attr_reader :first
+      def initialize(file)
+	 @characters = {}
+	 fh = File.open(file, 'r')
+	 while ln = fh.gets
+	    next if ln=~/^#/ or ln=~/^\s*$/
+	    r = ln.chomp.split /\t/
+	    @characters[ r[0] ] = Character.new(r[1],
+	       Decision.new(r[2]), Decision.new(r[3]))
+	    @first = @characters[ r[0] ] if @first.nil?
+	 end
+	 fh.close
+      end
+      def [](name)
+	 raise "Cannot find character #{name} in key." if @characters[name].nil?
+	 @characters[name]
+      end
+   end
+end
+module CharData
+   class Object
+      attr_reader :name, :states
+      def initialize(name)
+	 @name = name
+	 @states = {}
+      end
+      def <<(state) @states[state.character] = state ; end
+      def state(name) @states[name] ; end
+   end
+   class State
+      attr_reader :character, :state
+      def initialize(character, state)
+	 @character = character
+	 @state = state
+      end
+      def to_s() self.state.to_s ; end
+   end
+   class Table
+      attr_reader :objects
+      def initialize(file)
+	 @objects = []
+	 fh = File.open(file, 'r')
+	 header = fh.gets.chomp.split(/\t/)
+	 while ln = fh.gets
+	    next if ln=~/^#/ or ln=~/^\s*$/
+	    r = ln.chomp.split /\t/
+	    o = Object.new(r[0])
+	    (1 .. r.size).each{ |i| o << State.new(header[i], r[i]) }
+	    self << o
+	 end
+	 fh.close
+      end
+      def <<(object) @objects << object ; end
+   end
+end
+module ClassData
+   class Classification
+      attr_reader :key, :object, :result
+      def initialize key, object
+	 @key = key
+	 @object = object
+	 self.classify!
+      end
+      def classify!
+	 @result = self.key.first.eval(object)
+	 while ! self.result.terminal
+	    @result = self.key[ self.result.conclusion ].eval(object)
+	 end
+      end
+   end
+   class Collection
+      attr_reader :key, :table, :classifications
+      def initialize(key, table)
+	 @key = key
+	 @table = table
+	 @classifications = []
+	 self.classify!
+      end
+      def classify!
+	 table.objects.each do |object|
+	    @classifications << Classification.new(key, object)
+	 end
+      end
+      def classified_as(conclusion)
+         self.classifications.select{ |c|
+	    c.result.conclusion==conclusion }.map{ |c| c.object }
+      end
+      def to_nwk
+	 self.to_nwk_node(self.key.first) + ";"
+      end
+      def to_nwk_node(node)
+	 if node.is_a? Dychotomous::Character
+	    a = self.to_nwk_node(node.a)
+	    b = self.to_nwk_node(node.b)
+	    return "" if (a + b)==""
+	    return "(" + a + b + ")#{node.name.nwk_sanitize}" if a=="" or b==""
+	    return "(" + self.to_nwk_node(node.a) + "," +
+	       self.to_nwk_node(node.b) + ")#{node.name.nwk_sanitize}"
+	 end
+	 if node.is_a? Dychotomous::Decision and node.terminal
+	    objects = self.classified_as(node.conclusion)
+	    return '' if objects.empty?
+	    return objects[0].name.nwk_sanitize if objects.size==1
+	    return "(" + objects.map{|o| o.name.nwk_sanitize}.join(",") + ")"
+	 end
+	 return self.to_nwk_node( self.key[node.conclusion] ) if
+	    node.is_a? Dychotomous::Decision
+	 raise "Unsupported class: to_nwk_node: #{node}."
+      end
+   end
+end
+
+##### MAIN:
+begin
+   $stderr.puts "Reading dychotomous key." unless o[:q]
+   key = Dychotomous::Key.new(o[:key])
+   $stderr.puts "Reading character table." unless o[:q]
+   table = CharData::Table.new(o[:table])
+   $stderr.puts "Classifying objects." unless o[:q]
+   classif = ClassData::Collection.new(key, table)
+   
+   unless o[:class].nil?
+      $stderr.puts "Generating classification table." unless o[:q]
+      fh = File.open(o[:class], 'w')
+      classif.classifications.each do |c|
+         fh.puts c.object.name + "\t" + c.result.conclusion
+      end
+      fh.close
+   end
+
+   unless o[:nwk].nil?
+      $stderr.puts "Generating classification tree." unless o[:q]
+      fh = File.open(o[:nwk], 'w')
+      fh.puts classif.to_nwk
+      fh.close
+   end
+   
+rescue => err
+   $stderr.puts "Exception: #{err}\n\n"
+   err.backtrace.each { |l| $stderr.puts l + "\n" }
+   err
+end

data/utils/enveomics/Scripts/EBIseq2tax.rb

@@ -0,0 +1,83 @@
+#!/usr/bin/env ruby
+
+#
+# @author  Luis M. Rodriguez-R <lmrodriguezr at gmail dot com>
+# @update  Oct-13-2015
+# @license Artistic License 2.0
+#
+
+$:.push File.expand_path(File.dirname(__FILE__) + "/lib")
+require "enveomics_rb/remote_data"
+use "nokogiri"
+
+#================================[ Options parsing ]
+$o = {
+   q: false, ids: [], dbfrom: "uniprotkb", header: true,
+   ret: "ScientificName",
+   ranks: %w(superkingdom phylum class order family genus species)}
+
+OptionParser.new do |opt|
+   opt.banner = "
+   Maps a list of EBI-supported IDs to their corresponding NCBI taxonomy using
+   EBI RESTful API. Avoid using this script on millions of entries at a time,
+   since each entry elicits requests to EBI and NCBI servers.
+
+   Usage: #{$0} [options]".gsub(/^ +/,"")
+   opt.separator ""
+   opt.on("-i", "--ids ID1,ID2,...", Array,
+      "Comma-separated list of EBI IDs. Required unless -I is passed."
+      ){ |v| $o[:ids]=v }
+   opt.on("-I", "--infile FILE",
+      "Raw text file containing the list of EBI IDs, one per line.",
+      "Required unless -i is passed."){ |v| $o[:infile]=v }
+   opt.on("-d", "--database DB",
+      "EBI database defining the EBI IDs. By default: " + $o[:dbfrom].to_s + "."
+      ){ |v| $o[:dbfrom]=v }
+   opt.on("-r", "--ranks RANK1,RANK2,...", Array,
+      "Taxonomic ranks to report. By default:",
+      $o[:ranks].join(",") + "."){ |v| $o[:ranks]=v }
+   opt.on("-n", "--noheader",
+      "Do not includ a header in the output."){ $o[:header]=false }
+   opt.on("-t", "--taxids",
+      "Return Taxonomy IDs instead of scientific names."){ $o[:ret]="TaxId" }
+   opt.on("-q", "--quiet", "Run quietly."){ |v| $o[:q]=true }
+   opt.on("-h", "--help","Display this screen") do
+      puts opt
+      exit
+   end
+   opt.separator ""
+end.parse!
+
+#================================[ Main ]
+begin
+   $o[:ids] += File.readlines($o[:infile]).map{ |l| l.chomp } unless
+      $o[:infile].nil?
+   $o[:ranks].map!{ |r| r.downcase }
+   puts (["ID", "TaxId"] + $o[:ranks].map{ |r| r.capitalize }).join("\t") if
+      $o[:header]
+   $o[:ids].each do |id|
+      id = $1 if id =~ /^[a-z]+\|\S+\|(\S+)/
+      taxid = RemoteData.ebiseq2taxid(id, $o[:dbfrom])
+      if taxid.nil?
+	 warn "Cannot find link to taxonomy: #{id}"
+	 next
+      end
+      taxonomy = {}
+      unless taxid.nil?
+	 doc = Nokogiri::XML( RemoteData.efetch({db: "taxonomy", id: taxid}) )
+	 taxonomy[ doc.at_xpath("/TaxaSet/Taxon/Rank").content ] =
+	    doc.at_xpath("/TaxaSet/Taxon/#{$o[:ret]}").content
+	 doc.xpath("/TaxaSet/Taxon/LineageEx/Taxon").each do |taxon|
+	    taxonomy[ taxon.at_xpath("./Rank").content ] =
+	       taxon.at_xpath("./#{$o[:ret]}").content
+	 end
+      end
+      puts ([id, taxid] +
+	 $o[:ranks].map{ |rank| taxonomy[ rank ] ||= "" }).join("\t")
+   end # $o[:ids].each
+rescue => err
+   $stderr.puts "Exception: #{err}\n\n"
+   err.backtrace.each { |l| $stderr.puts l + "\n" }
+   err
+end
+

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

@@ -0,0 +1,56 @@
+#!/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/sum min max/;
+
+my ($seqs, $minlen, $n__) = @ARGV;
+$seqs or die "
+Description:
+   Calculates the N50 value of a set of sequences.  Alternatively, it
+   can calculate other N** values.  It also calculates the total number
+   of sequences and the total added length.
+   
+Usage:
+   $0 seqs.fa[ minlen[ **]]
+
+   seqs.fa	A FastA file containing the sequences.
+   minlen	(optional) The minimum length to take into consideration.
+   		By default: 0.
+   **		Value N** to calculate.  By default: 50 (N50).
+";
+$minlen ||= 0;
+$n__    ||= 50;
+
+my @len = ();
+open SEQ, "<", $seqs or die "Cannot open file: $seqs: $!\n";
+while(<SEQ>){
+   if(/^>/){
+      push @len, 0;
+   }else{
+      next if /^;/;
+      chomp;
+      s/\W//g;
+      $len[-1]+=length $_;
+   }
+}
+close SEQ;
+@len = sort { $a <=> $b } map { $_>=$minlen?$_:() } @len;
+my $tot = (sum(@len) || 0);
+
+my $thr = $n__*$tot/100;
+my $pos = 0;
+for(@len){
+   $pos+= $_;
+   if($pos>=$thr){
+      print "N$n__: $_\n";
+      last;
+   }
+}
+print "Sequences: ".scalar(@len)."\n";
+print "Total length: $tot\n";
+

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

@@ -0,0 +1,52 @@
+#!/usr/bin/env perl
+#
+# @author  Luis M. Rodriguez-R <lmrodriguezr at gmail dot com>
+# @update  Oct-07-2015
+# @license artistic license 2.0
+#
+
+use warnings;
+use strict;
+use Getopt::Std;
+
+sub HELP_MESSAGE { die "
+.Description:
+   Extracts a subset of sequences from a FastA file.
+
+.Usage: $0 [options] list.txt seqs.fa > subset.fa
+   
+   [options]
+   -r		Reverse list.  Extracts sequences NOT present in the list.
+   -q		Runs quietly.
+   -h		Prints this message and exits.
+
+   [mandatory]
+   list.txt	List of sequences to extract.
+   seqs.fa	FastA file containing the superset of sequences.
+   subset.fa	FastA file to be created.
+
+" }
+
+my %o=();
+getopts('rhq', \%o);
+my($list, $fa) = @ARGV;
+($list and $fa) or &HELP_MESSAGE;
+$o{h} and &HELP_MESSAGE;
+
+print STDERR "Reading list.\n" unless $o{q};
+open LI, "<", $list or die "Cannot read file: $list: $!\n";
+my %li = map { chomp; $_ => 1 } <LI>;
+close LI;
+
+print STDERR "Filtering FastA.\n" unless $o{q};
+open FA, "<", $fa or die "Cannot read file: $fa: $!\n";
+my $good = 0;
+while(my $ln = <FA>){
+   next if $ln =~ /^;/;
+   chomp $ln;
+   if($ln =~ m/^>((\S+).*)/){ $good = (exists $li{$1} or exists $li{">$1"} or exists $li{$2} or exists $li{$ln}) }
+   elsif($ln =~ m/^>/){ $good=$o{r}; print STDERR "Warning: Non-cannonical defline, line $.: $ln\n" }
+   print "$ln\n" if (($good and not $o{r}) or ($o{r} and not $good));
+}
+close FA;
+

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

@@ -0,0 +1,28 @@
+#!/usr/bin/env perl
+
+use warnings;
+use strict;
+use Bio::SeqIO;
+
+my $file = $ARGV[0]; 
+my $min = $ARGV[1];
+($file and $min) or die <<HELP
+
+This script will filter a multi fastA file by length
+
+Usage "perl $0 fastafile minlenght "
+HELP
+;
+my $seq_in  = Bio::SeqIO->new( -format => 'fasta',-file => $file);
+
+while( my $seq1 = $seq_in->next_seq() ) {	
+	
+	my $id  = $seq1->primary_id;
+	chomp $id;
+	my $seq = $seq1->seq;
+	chomp $seq;
+	my $lseq = length($seq);
+	if($lseq>=$min){
+		print ">$id","\n",$seq,"\n";	
+	}
+}