miga-base 0.7.26.2 → 1.0.3.0

data/utils/enveomics/Scripts/rbm-legacy.rb

@@ -0,0 +1,172 @@
+#!/usr/bin/env ruby
+
+# frozen_string_literal: true
+
+$VERSION = 0.1
+$:.push File.expand_path('../lib', __FILE__)
+require 'enveomics_rb/enveomics'
+require 'tmpdir'
+
+o = {
+  q: false, thr: 1,
+  len: 0, id: 0.0, fract: 0.0, score: 0.0,
+  bin: '', program: :'blast+', nucl: false
+}
+
+OptionParser.new do |opts|
+  cmd = File.basename($0)
+  opts.banner = <<~BANNER
+
+    [Enveomics Collection: #{cmd} v#{$VERSION}]
+
+    [DEPRECATED: Please use rbm.rb instead]
+
+    Finds the reciprocal best matches between two sets of sequences
+
+    Usage: #{cmd} [options]
+
+  BANNER
+
+  opts.separator 'Mandatory'
+  opts.on(
+    '-1', '--seq1 FILE',
+    'Path to the FastA file containing the set 1'
+  ) { |v| o[:seq1] = v }
+  opts.on(
+    '-2', '--seq2 FILE',
+    'Path to the FastA file containing the set 2'
+  ) { |v| o[:seq2] = v }
+  opts.separator ''
+  opts.separator 'Search Options'
+  opts.on(
+    '-n', '--nucl',
+    'Sequences are assumed to be nucleotides (proteins by default)',
+    'Incompatible with -p diamond'
+  ) { |v| o[:nucl] = true }
+  opts.on(
+    '-l', '--len INT', Integer,
+    'Minimum alignment length (in residues)',
+    "By default: #{o[:len]}"
+  ) { |v| o[:len] = v }
+  opts.on(
+    '-f', '--fract FLOAT', Float,
+    'Minimum alignment length (as a fraction of the query)',
+    'If set, requires BLAST+ or Diamond (see -p)',
+    "By default: #{o[:fract]}"
+  ) { |v| o[:fract] = v }
+  opts.on(
+    '-i', '--id NUM', Float,
+    'Minimum alignment identity (in %)',
+    "By default: #{o[:id]}"
+  ){ |v| o[:id] = v }
+  opts.on(
+    '-s', '--score NUM', Float,
+    'Minimum alignment score (in bits)',
+    "By default: #{o[:score]}"
+  ) { |v| o[:score] = v }
+  opts.separator ''
+  opts.separator 'Software Options'
+  opts.on(
+    '-b', '--bin DIR',
+    'Path to the directory containing the binaries of the search program'
+  ) { |v| o[:bin] = v }
+  opts.on(
+    '-p', '--program STR',
+    'Search program to be used.  One of: blast+ (default), blast, diamond'
+  ) { |v| o[:program] = v.downcase.to_sym }
+  opts.on(
+    '-t', '--threads INT', Integer,
+    'Number of parallel threads to be used',
+    "By default: #{o[:thr]}"
+  ) { |v| o[:thr] = 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') { puts opts ; exit }
+  opts.separator ''
+end.parse!
+
+abort '-1 is mandatory' if o[:seq1].nil?
+abort '-2 is mandatory' if o[:seq2].nil?
+if o[:program] == :diamond && o[:nucl]
+  abort '-p diamond is incompatible with -n'
+end
+if o[:fract] > 0.0 && o[:program] == :blast
+  abort 'Argument -f/--fract requires -p blast+ or -p diamond'
+end
+o[:bin] = o[:bin] + '/' if o[:bin].size > 0
+$quiet = o[:q]
+
+Dir.mktmpdir do |dir|
+  say('Temporal directory: ', dir)
+
+  # Create databases
+  say 'Creating databases'
+  [:seq1, :seq2].each do |seq|
+    case o[:program]
+    when :blast
+      `"#{o[:bin]}formatdb" -i "#{o[seq]}" -n "#{dir}/#{seq}" \
+        -p #{o[:nucl] ? 'F' : 'T'}`
+    when :'blast+'
+      `"#{o[:bin]}makeblastdb" -in "#{o[seq]}" -out "#{dir}/#{seq}" \
+        -dbtype #{o[:nucl] ? 'nucl' : 'prot'}`
+    when :diamond
+      `"#{o[:bin]}diamond" makedb --in "#{o[seq]}" \
+        --db "#{dir}/#{seq}.dmnd" --threads "#{o[:thr]}"`
+    else
+      abort "Unsupported program: #{o[:program]}"
+    end
+  end
+
+  # Best-hits
+  rbh = {}
+  n2 = 0
+  say ' Running comparisons'
+  [2, 1].each do |i|
+    qry_seen = {}
+    q = o[:"seq#{i}"]
+    s = "#{dir}/seq#{i == 1 ? 2 : 1}"
+    say('  Query: ', q)
+    case o[:program]
+    when :blast
+      `"#{o[:bin]}blastall" -p #{o[:nucl] ? 'blastn' : 'blastp'} -d "#{s}" \
+        -i "#{q}" -v 1 -b 1 -a #{o[:thr]} -m 8 -o "#{dir}/#{i}.tab"`
+    when :'blast+'
+      `"#{o[:bin]}#{o[:nucl] ? 'blastn' : 'blastp'}" -db "#{s}" -query "#{q}" \
+        -max_target_seqs 1 -num_threads #{o[:thr]} -out "#{dir}/#{i}.tab" \
+        -outfmt "6 qseqid sseqid pident length mismatch gapopen qstart qend \
+        sstart send evalue bitscore qlen slen"`
+    when :diamond
+      `"#{o[:bin]}diamond" blastp --threads "#{o[:thr]}" --db "#{s}.dmnd" \
+        --query "#{q}" --sensitive --daa "#{dir}/#{i}.daa" --quiet \
+        && "#{o[:bin]}diamond" view --daa "#{dir}/#{i}.daa" --outfmt \
+        6 qseqid sseqid pident length mismatch gapopen qstart qend sstart \
+        send evalue bitscore qlen slen --out "#{dir}/#{i}.tab" --quiet`
+    else
+      abort "Unsupported program: #{o[:program]}"
+    end
+
+    n = 0
+    File.open("#{dir}/#{i}.tab", 'r') do |fh|
+      fh.each do |ln|
+        ln.chomp!
+        row = ln.split(/\t/)
+        row[12] = '1' unless [:'blast+', :diamond].include? o[:program]
+        next unless qry_seen[row[0]].nil? &&
+          row[3].to_i >= o[:len] && row[2].to_f >= o[:id] &&
+          row[11].to_f >= o[:score] && row[3].to_f / row[12].to_i >= o[:fract]
+
+        qry_seen[row[0]] = 1
+        n += 1
+        if i == 2
+          rbh[row[0]] = row[1]
+        elsif !rbh[row[1]].nil? && rbh[row[1]] == row[0]
+          puts ln
+          n2 += 1
+        end
+      end
+    end
+    say "    #{n} sequences with hit"
+  end
+  say "  #{n2} RBMs"
+end

data/utils/enveomics/Scripts/rbm.rb

@@ -1,146 +1,100 @@
 #!/usr/bin/env ruby
 
-#
-# @author: Luis M. Rodriguez-R
-# @update: Aug-25-2015
-# @license: artistic license 2.0
-#
+# frozen_string_literal: true
 
-require 'optparse'
+$VERSION = 1.0
+$:.push File.expand_path('../lib', __FILE__)
+require 'enveomics_rb/rbm'
 require 'tmpdir'
 
-o = {len:0, id:0, fract:0, score:0, q:false, bin:"", program:"blast+", thr:1,
-   nucl:false}
-ARGV << "-h" if ARGV.size==0
+bms_dummy = Enveomics::RBM.new('1', '2').bms1
+o = { q: false }
+%i[thr len id fract score bin program nucl].each do |k|
+  o[k] = bms_dummy.opt(k)
+end
+
 OptionParser.new do |opts|
-   opts.banner = "
-Finds the reciprocal best matches between two sets of sequences.
+  cmd = File.basename($0)
+  opts.banner = <<~BANNER
 
-Usage: #{$0} [options]"
-   opts.separator ""
-   opts.separator "Mandatory"
-   opts.on("-1", "--seq1 FILE",
-      "Path to the FastA file containing the set 1."){ |v| o[:seq1] = v }
-   opts.on("-2", "--seq2 FILE",
-      "Path to the FastA file containing the set 2."){ |v| o[:seq2] = v }
-   opts.separator ""
-   opts.separator "Search Options"
-   opts.on("-n", "--nucl",
-      "Sequences are assumed to be nucleotides (proteins by default)."
-      ){ |v| o[:nucl] = true }
-   opts.on("-l", "--len INT",
-      "Minimum alignment length (in residues).  By default: #{o[:len]}."
-      ){ |v| o[:len] = v.to_i }
-   opts.on("-f", "--fract FLOAT",
-      "Minimum alignment length (as a fraction of the query).",
-      "If set, requires BLAST+ or Diamond (see -p).  By default: #{o[:fract]}."
-      ){ |v| o[:fract] = v.to_i }
-   opts.on("-i", "--id NUM",
-      "Minimum alignment identity (in %).  By default: #{o[:id].to_s}."
-      ){ |v| o[:id] = v.to_f }
-   opts.on("-s", "--score NUM",
-      "Minimum alignment score (in bits).  By default: #{o[:score]}."
-      ){ |v| o[:score] = v.to_f }
-   opts.separator ""
-   opts.separator "Software Options"
-   opts.on("-b", "--bin DIR",
-      "Path to the directory containing the binaries of the search program."
-      ){ |v| o[:bin] = v }
-   opts.on("-p", "--program STR",
-      "Search program to be used.  One of: blast+ (default), blast, diamond."
-      ){ |v| o[:program] = v }
-   opts.on("-t", "--threads INT",
-      "Number of parallel threads to be used.  By default: #{o[:thr]}."
-      ){ |v| o[:thr] = v.to_i }
-   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 "-1 is mandatory" if o[:seq1].nil?
-abort "-2 is mandatory" if o[:seq2].nil?
-abort '-p diamond is incompatible with -n' if o[:program]=='diamond' && o[:nucl]
-abort 'Argument -f/--fract requires -p blast+ or -p diamond' if
-   o[:fract]>0 and o[:program]!='blast+' and o[:program]!='diamond'
-o[:bin] = o[:bin]+"/" if o[:bin].size > 0
+    [Enveomics Collection: #{cmd} v#{$VERSION}]
 
-Dir.mktmpdir do |dir|
-   $stderr.puts "Temporal directory: #{dir}." unless o[:q]
+    Finds the reciprocal best matches between two sets of sequences
 
-   # Create databases.
-   $stderr.puts "Creating databases." unless o[:q]
-   [:seq1, :seq2].each do |seq|
-      case o[:program].downcase
-      when 'blast'
-         `"#{o[:bin]}formatdb" -i "#{o[seq]}" -n "#{dir}/#{seq}" \
-	 -p #{(o[:nucl]?"F":"T")}`
-      when 'blast+'
-         `"#{o[:bin]}makeblastdb" -in "#{o[seq]}" -out "#{dir}/#{seq}" \
-	 -dbtype #{(o[:nucl]?"nucl":"prot")}`
-      when 'diamond'
-         `"#{o[:bin]}diamond" makedb --in "#{dir}/#{seq}.fa" \
-         --db "#{dir}/#{seq}.fa.dmnd" --threads "#{o[:thr]}"`
-      else
-         abort "Unsupported program: #{o[:program]}."
-      end
-   end # |seq|
+    Usage: #{cmd} [options]
 
-   # Best-hits.
-   rbh = {}
-   n2 = 0
-   $stderr.puts " Running comparisons." unless o[:q]
-   [2,1].each do |i|
-      qry_seen = {}
-      q = o[:"seq#{i}"]
-      s = "#{dir}/seq#{i==1?2:1}"
-      $stderr.puts "  Query: #{q}." unless o[:q]
-      case o[:program].downcase
-      when 'blast'
-	 `"#{o[:bin]}blastall" -p #{o[:nucl]?"blastn":"blastp"} -d "#{s}" \
-	 -i "#{q}" -v 1 -b 1 -a #{o[:thr]} -m 8 -o "#{dir}/#{i}.tab"`
-      when 'blast+'
-	 `"#{o[:bin]}#{o[:nucl]?"blastn":"blastp"}" -db "#{s}" -query "#{q}" \
-	 -max_target_seqs 1 -num_threads #{o[:thr]} -out "#{dir}/#{i}.tab" \
-	 -outfmt "6 qseqid sseqid pident length mismatch gapopen qstart qend \
-	 sstart send evalue bitscore qlen slen"`
-      when 'diamond'
-         `"#{o[:bin]}diamond" blastp --threads "#{o[:thr]}" \
-         --outfmt "6 qseqid sseqid pident length mismatch gapopen qstart qend \
-         sstart send evalue bitscore qlen slen" --db "#{s}.dmnd" \
-         --query "#{q}" --out "#{dir}/#{i}.tab" --more-sensitive`
-      else
-	 abort "Unsupported program: #{o[:program]}."
-      end
-      fh = File.open("#{dir}/#{i}.tab", "r")
-      n = 0
-      fh.each_line do |ln|
-	 ln.chomp!
-	 row = ln.split(/\t/)
-	 row[12] = "1" unless %w[blast+ diamond].include? o[:program]
-	 if qry_seen[ row[0] ].nil? and row[3].to_i >= o[:len] and
-	       row[2].to_f >= o[:id] and row[11].to_f >= o[:score] and
-	       row[3].to_f/row[12].to_i >= o[:fract]
-	    qry_seen[ row[0] ] = 1
-	    n += 1
-	    if i==2
-	       rbh[ row[0] ] = row[1]
-	    else
-	       if !rbh[ row[1] ].nil? and rbh[ row[1] ]==row[0]
-		  puts ln
-		  n2 += 1
-	       end
-	    end
-	 end
-      end # |ln|
-      fh.close()
-      $stderr.puts "    #{n} sequences with hit." unless o[:q]
-   end # |i|
-   $stderr.puts "  #{n2} RBMs." unless o[:q]
-end # |dir|
+  BANNER
+
+  opts.separator 'Mandatory'
+  opts.on(
+    '-1', '--seq1 FILE',
+    'Path to the FastA file containing the set 1'
+  ) { |v| o[:seq1] = v }
+  opts.on(
+    '-2', '--seq2 FILE',
+    'Path to the FastA file containing the set 2'
+  ) { |v| o[:seq2] = v }
+  opts.separator ''
+  opts.separator 'Search Options'
+  opts.on(
+    '-n', '--nucl',
+    'Sequences are assumed to be nucleotides (proteins by default)',
+    'Incompatible with -p diamond'
+  ) { |v| o[:nucl] = true }
+  opts.on(
+    '-l', '--len INT', Integer,
+    'Minimum alignment length (in residues)',
+    "By default: #{o[:len]}"
+  ) { |v| o[:len] = v }
+  opts.on(
+    '-f', '--fract FLOAT', Float,
+    'Minimum alignment length (as a fraction of the query)',
+    'If set, requires BLAST+ or Diamond (see -p)',
+    "By default: #{o[:fract]}"
+  ) { |v| o[:fract] = v }
+  opts.on(
+    '-i', '--id NUM', Float,
+    'Minimum alignment identity (in %)',
+    "By default: #{o[:id]}"
+  ){ |v| o[:id] = v }
+  opts.on(
+    '-s', '--score NUM', Float,
+    'Minimum alignment score (in bits)',
+    "By default: #{o[:score]}"
+  ) { |v| o[:score] = v }
+  opts.separator ''
+  opts.separator 'Software Options'
+  opts.on(
+    '-b', '--bin DIR',
+    'Path to the directory containing the binaries of the search program'
+  ) { |v| o[:bin] = v }
+  opts.on(
+    '-p', '--program STR',
+    'Search program to be used',
+    'One of: blast+ (default), blast, diamond, blat'
+  ) { |v| o[:program] = v.downcase.to_sym }
+  opts.on(
+    '-t', '--threads INT', Integer,
+    'Number of parallel threads to be used',
+    "By default: #{o[:thr]}"
+  ) { |v| o[:thr] = 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') { puts opts ; exit }
+  opts.separator ''
+end.parse!
 
+raise Enveomics::OptionError.new('-1 is mandatory') if o[:seq1].nil?
+raise Enveomics::OptionError.new('-2 is mandatory') if o[:seq2].nil?
+raise Enveomics::OptionError.new(
+  'Argument -f/--fract requires -p blast+ or -p diamond'
+) if o[:fract] > 0.0 && !%i[blast+ diamond].include?(o[:program])
+$QUIET = o[:q]
 
+rbm = Enveomics::RBM.new(o[:seq1], o[:seq2], o)
+rbm.each { |bm| puts bm.to_s }
+say('Forward Best Matches: ', rbm.bms1.count)
+say('Reverse Best Matches: ', rbm.bms2.count)
+say('Reciprocal Best Matches: ', rbm.count)
 

data/utils/enveomics/Scripts/sam.filter.rb

@@ -0,0 +1,148 @@
+#!/usr/bin/env ruby
+
+# frozen_string_literal: true
+
+$VERSION = 1.0
+$:.push File.expand_path('../lib', __FILE__)
+require 'enveomics_rb/enveomics'
+use 'shellwords'
+
+o = {
+  q: false, threads: 2, m_format: :sam, g_format: :fasta, identity: 95.0,
+  o: '-', header: true
+}
+
+OptionParser.new do |opt|
+  Enveomics.opt_banner(
+    opt, 'Filters a SAM or BAM file by target sequences and/or identity',
+    "#{File.basename($0)} -m map.sam -o filtered_map.sam [options]"
+  )
+
+  opt.separator 'Input/Output'
+  opt.on(
+    '-g', '--genome PATH',
+    'Genome assembly',
+    'Supports compression with .gz extension, use - for STDIN'
+  ) { |v| o[:g] = v }
+  opt.on(
+    '-m', '--mapping PATH',
+    'Mapping file',
+    'Supports compression with .gz extension, use - for STDIN'
+  ) { |v| o[:m] = v }
+  opt.on(
+    '-o', '--out-sam PATH',
+    'Output filtered file in SAM format',
+    'Supports compression with .gz extension, use - for STDOUT (default)'
+  ) { |v| o[:o] = v }
+  opt.separator ''
+
+  opt.separator 'Formats'
+  opt.on(
+    '--g-format STRING',
+    'Genome assembly format: fasta (default) or list'
+  ) { |v| o[:g_format] = v.downcase.to_sym }
+  opt.on(
+    '--m-format STRING',
+    'Mapping file format: sam (default) or bam',
+    'sam supports compression with .gz file extension'
+  ) { |v| o[:m_format] = v.downcase.to_sym }
+  opt.separator ''
+
+  opt.separator 'General'
+  opt.on(
+    '-i', '--identity FLOAT', Float,
+    "Set a fixed threshold of percent identity (default: #{o[:identity]})"
+  ) { |v| o[:identity] = v }
+  opt.on('--no-header', 'Do not include the headers') { |v| o[:header] = v }
+  opt.separator ''
+  opt.on(
+    '-t', '--threads INT', Integer, "Threads to use (default: #{o[:threads]})"
+  ) { |v| o[:threads] = v }
+  opt.on('-l', '--log PATH', 'Log file to save output') { |v| o[:log] = v }
+  opt.on('-q', '--quiet', 'Run quietly') { |v| o[:q] = v }
+  opt.on('-h', '--help', 'Display this screen') do
+    puts opt
+    exit
+  end
+  opt.separator ''
+end.parse!
+
+$QUIET = o[:q]
+
+# Functions
+
+##
+# Parses one line +ln+ in SAM format and outputs filtered lines to +ofh+
+# Filters by minimum +identity+ and +target+ sequences, and prints
+# the headers if +header+
+def parse_sam_line(ln, identity, target, header, ofh)
+  if ln =~ /^@/ || ln =~ /^\s*$/
+    ofh.puts ln if header
+    return
+  end
+
+  # No match
+  row = ln.chomp.split("\t")
+  return if row[2] == '*'
+
+  # Filter by target
+  return if !target.nil? && !target.include?(row[2])
+
+  # Exclude unless concordant or unaligned
+  length = row[9].size
+  row.shift(11) # Discard non-flag columns
+  flags = Hash[row.map { |i| i.sub(/:.:/, ':').split(':', 2) }]
+  return if flags['YT'] && !%w[CP UU].include?(flags['YT'])
+
+  # Filter by identity
+  unless flags['MD']
+    raise Enveomics::ParseError.new(
+      "SAM line missing MD flag:\n#{ln}\nFlags: #{flags}"
+    )
+  end
+  mismatches = flags['MD'].scan(/[^\d]/).count
+  id = 100.0 * (length - mismatches) / length
+  ofh.puts ln if id >= identity
+end
+
+# Reading targets
+if o[:g]
+  say 'Loading target sequences to filter'
+  reader = reader(o[:g])
+  target =
+    case o[:g_format]
+    when :fasta
+      reader.each.map { |ln| $1 if ln =~ /^>(\S+)/ }.compact
+    when :list
+      reader.each.map(&:chomp)
+    else
+      raise Enveomics::OptionError.new(
+        "Unsupported target sequences format: #{o[:g_format]}"
+      )
+    end
+  reader.close
+else
+  target = nil
+end
+
+# Reading and filtering mapping
+say 'Reading mapping file'
+ofh = writer(o[:o])
+case o[:m_format]
+when :sam
+  reader = reader(o[:m])
+  reader.each { |ln| parse_sam_line(ln, o[:identity], target, o[:header], ofh) }
+  reader.close
+when :bam
+  cmd = ['samtools', 'view', o[:m], '-@', o[:threads]]
+  cmd << '-h' if o[:header]
+  IO.popen(cmd.shelljoin) do |fh|
+    fh.each { |ln| parse_sam_line(ln, o[:identity], target, o[:header], ofh) }
+  end
+else
+  raise Enveomics::OptionError.new(
+    "Unsupported mapping format: #{o[:m_format]}"
+  )
+end
+ofh.close
+