miga-base 0.4.3.0 → 0.5.0.0

data/lib/miga/cli/action/preproc_wf.rb

@@ -0,0 +1,46 @@
+# @package MiGA
+# @license Artistic-2.0
+
+require 'miga/cli/action'
+
+class MiGA::Cli::Action::PreprocWf < MiGA::Cli::Action
+  require 'miga/cli/action/wf'
+  require 'miga/cli/action/add'
+  include MiGA::Cli::Action::Wf
+
+  def parse_cli
+    default_opts_for_wf
+    cli.defaults = { mytaxa: false }
+    cli.parse do |opt|
+      opt.on(
+        '-i', '--input-type STRING',
+        '(Mandatory) Type of input data, one of the following:',
+        *MiGA::Cli::Action::Add.INPUT_TYPES.map{ |k,v| "~ #{k}: #{v[0]}" }
+      ) { |v| cli[:input_type] = v.downcase.to_sym }
+      opt.on(
+        '-m', '--mytaxa_scan',
+        'Perform MyTaxa scan analysis'
+      ) { |v| cli[:mytaxa] = v }
+      opts_for_wf(opt, 'Input files as defined by --input-type',
+        multi: true, cleanup: false, ncbi: false)
+    end
+  end
+
+  def perform
+    # Input data
+    cli.ensure_par(input_type: '-i')
+    p_metadata = Hash[
+      %w[project_stats haai_distances aai_distances ani_distances clade_finding]
+        .map { |i| ["run_#{i}", false] }
+    ]
+    d_metadata = { run_distances: false }
+    unless cli[:mytaxa]
+      d_metadata[:run_mytaxa_scan] = false
+      d_metadata[:run_mytaxa] = false
+    end
+    p = create_project(cli[:input_type], p_metadata, d_metadata)
+    # Run
+    run_daemon
+    summarize
+  end
+end

data/lib/miga/cli/action/quality_wf.rb

@@ -0,0 +1,45 @@
+# @package MiGA
+# @license Artistic-2.0
+
+require 'miga/cli/action'
+
+class MiGA::Cli::Action::QualityWf < MiGA::Cli::Action
+  require 'miga/cli/action/wf'
+  include MiGA::Cli::Action::Wf
+
+  def parse_cli
+    default_opts_for_wf
+    cli.defaults = { mytaxa: false }
+    cli.parse do |opt|
+      opt.on(
+        '-m', '--mytaxa-scan',
+        'Perform MyTaxa scan analysis'
+      ) { |v| cli[:mytaxa] = v }
+      opts_for_wf(opt, 'Input genome assemblies (nucleotides, FastA)')
+    end
+  end
+
+  def perform
+    # Input data
+    p_metadata = Hash[
+      %w[project_stats haai_distances aai_distances ani_distances clade_finding]
+        .map { |i| ["run_#{i}", false] }
+    ]
+    d_metadata = { run_distances: false }
+    d_metadata[:run_mytaxa_scan] = false unless cli[:mytaxa]
+    p = create_project(:assembly, p_metadata, d_metadata)
+    # Run
+    run_daemon
+    summarize
+    if cli[:mytaxa]
+      dir = File.expand_path('mytaxa_scan', cli[:outdir])
+      Dir.mkdir(dir)
+      p.each_dataset do |d|
+        r = d.result(:mytaxa_scan) or next
+        f = r.file_path(:report) or next
+        FileUtils.cp(f, dir)
+      end
+    end
+    cleanup
+  end
+end

data/lib/miga/cli/action/stats.rb

@@ -6,21 +6,21 @@ require 'miga/cli/action'
 class MiGA::Cli::Action::Stats < MiGA::Cli::Action
 
   def parse_cli
-    cli.defaults = {try_load: false}
+    cli.defaults = { try_load: false }
     cli.parse do |opt|
       cli.opt_object(opt, [:project, :dataset_opt, :result])
       opt.on(
         '--key STRING',
         'Return only the value of the requested key'
-        ){ |v| cli[:key] = v }
+      ) { |v| cli[:key] = v }
       opt.on(
         '--compute-and-save',
         'Compute and saves the statistics'
-        ){ |v| cli[:compute] = v }
+      ) { |v| cli[:compute] = v }
       opt.on(
         '--try-load',
         'Check if stat exists instead of computing on --compute-and-save'
-        ){ |v| cli[:try_load] = v }
+      ) { |v| cli[:try_load] = v }
     end
   end
 
@@ -30,111 +30,159 @@ class MiGA::Cli::Action::Stats < MiGA::Cli::Action
     r = cli.load_result
     if cli[:compute]
       cli.say 'Computing statistics'
-      stats = {}
-      case cli[:result]
-      when :raw_reads
-        if r[:files][:pair1].nil?
-          s = MiGA.seqs_length(r.file_path(:single), :fastq, gc: true)
-          stats = {
-            reads: s[:n],
-            length_average: [s[:avg], 'bp'],
-            length_standard_deviation: [s[:sd], 'bp'],
-            g_c_content: [s[:gc], '%']}
-        else
-          s1 = MiGA.seqs_length(r.file_path(:pair1), :fastq, gc: true)
-          s2 = MiGA.seqs_length(r.file_path(:pair2), :fastq, gc: true)
-          stats = {
-            read_pairs: s1[:n],
-            forward_length_average: [s1[:avg], 'bp'],
-            forward_length_standard_deviation: [s1[:sd], 'bp'],
-            forward_g_c_content: [s1[:gc], '%'],
-            reverse_length_average: [s2[:avg], 'bp'],
-            reverse_length_standard_deviation: [s2[:sd], 'bp'],
-            reverse_g_c_content: [s2[:gc], '%']}
-        end
-      when :trimmed_fasta
-        f = r[:files][:coupled].nil? ? r.file_path(:single) : r.file_path(:coupled)
-        s = MiGA.seqs_length(f, :fasta, gc: true)
-        stats = {
-          reads: s[:n],
-          length_average: [s[:avg], 'bp'],
-          length_standard_deviation: [s[:sd], 'bp'],
-          g_c_content: [s[:gc], '%']}
-      when :assembly
-        s = MiGA.seqs_length(r.file_path(:largecontigs), :fasta,
-          n50: true, gc: true)
-        stats = {
-          contigs: s[:n],
-          n50: [s[:n50], 'bp'],
-          total_length: [s[:tot], 'bp'],
-          g_c_content: [s[:gc], '%']}
-      when :cds
-        s = MiGA.seqs_length(r.file_path(:proteins), :fasta)
-        stats = {
-          predicted_proteins: s[:n],
-          average_length: [s[:avg], 'aa']}
-        asm = cli.load_dataset.add_result(:assembly, false)
-        unless asm.nil? or asm[:stats][:total_length].nil?
-          stats[:coding_density] =
-            [300.0 * s[:tot] / asm[:stats][:total_length][0], '%']
-        end
-      when :essential_genes
-        d = cli.load_dataset
-        if d.is_multi?
-          stats = {median_copies: 0, mean_copies: 0}
-          File.open(r.file_path(:report), 'r') do |fh|
-            fh.each_line do |ln|
-              if /^! (Mean|Median) number of copies per model: (.*)\./.match(ln)
-                stats["#{$1.downcase}_copies".to_sym] = $2.to_f
-              end
-            end
-          end
-        else
-          # Fix estimate for Archaea
-          if not d.metadata[:tax].nil? &&
-                d.metadata[:tax].in?(Taxonomy.new('d:Archaea')) &&
-                r.file_path(:bac_report).nil?
-            scr = "#{MiGA.root_path}/utils/arch-ess-genes.rb"
-            rep = r.file_path(:report)
-            $stderr.print `ruby '#{scr}' '#{rep}' '#{rep}.archaea'`
-            r.add_file(:bac_report, "#{d.name}.ess/log")
-            r.add_file(:report, "#{d.name}.ess/log.archaea")
-          end
-          # Extract/compute quality values
-          stats = {completeness: [0.0, '%'], contamination: [0.0, '%']}
-          File.open(r.file_path(:report), 'r') do |fh|
-            fh.each_line do |ln|
-              if /^! (Completeness|Contamination): (.*)%/.match(ln)
-                stats[$1.downcase.to_sym][0] = $2.to_f
-              end
-            end
-          end
-          stats[:quality] = stats[:completeness][0] - stats[:contamination][0] * 5
-          d.metadata[:quality] = case stats[:quality]
-            when 80..100 ; :excellent
-            when 50..80  ; :high
-            when 20..50  ; :intermediate
-            else         ; :low
-          end
-          d.save
-        end
-      else
-        stats = nil
-      end
+      method = :"compute_#{cli[:result]}"
+      stats = self.respond_to?(method, true) ? send(method, r) : nil
       unless stats.nil?
         r[:stats] = stats
         r.save
       end
     end
-
     if cli[:key].nil?
-      r[:stats].each do |k,v|
-        cli.puts "#{k==:g_c_content ? 'G+C content' : k.to_s.unmiga_name.capitalize}: #{
-          v.is_a?(Array) ? v.join(' ') : v}."
+      r[:stats].each do |k, v|
+        k_n = k == :g_c_content ? 'G+C content' : k.to_s.unmiga_name.capitalize
+        cli.puts "#{k_n}: #{v.is_a?(Array) ? v.join(' ') : v}"
       end
     else
       v = r[:stats][cli[:key].downcase.miga_name.to_sym]
       puts v.is_a?(Array) ? v.first : v
     end
   end
+
+  private
+
+  def compute_raw_reads(r)
+    stats = {}
+    if r[:files][:pair1].nil?
+      s = MiGA.seqs_length(r.file_path(:single), :fastq, gc: true)
+      stats = {
+        reads: s[:n],
+        length_average: [s[:avg], 'bp'],
+        length_standard_deviation: [s[:sd], 'bp'],
+        g_c_content: [s[:gc], '%']}
+    else
+      s1 = MiGA.seqs_length(r.file_path(:pair1), :fastq, gc: true)
+      s2 = MiGA.seqs_length(r.file_path(:pair2), :fastq, gc: true)
+      stats = {
+        read_pairs: s1[:n],
+        forward_length_average: [s1[:avg], 'bp'],
+        forward_length_standard_deviation: [s1[:sd], 'bp'],
+        forward_g_c_content: [s1[:gc], '%'],
+        reverse_length_average: [s2[:avg], 'bp'],
+        reverse_length_standard_deviation: [s2[:sd], 'bp'],
+        reverse_g_c_content: [s2[:gc], '%']}
+    end
+    stats
+  end
+
+  def compute_trimmed_fasta(r)
+    f = r[:files][:coupled].nil? ? r.file_path(:single) : r.file_path(:coupled)
+    s = MiGA.seqs_length(f, :fasta, gc: true)
+    {
+      reads: s[:n],
+      length_average: [s[:avg], 'bp'],
+      length_standard_deviation: [s[:sd], 'bp'],
+      g_c_content: [s[:gc], '%']
+    }
+  end
+
+  def compute_assembly(r)
+    s = MiGA.seqs_length(r.file_path(:largecontigs), :fasta,
+      n50: true, gc: true)
+    {
+      contigs: s[:n],
+      n50: [s[:n50], 'bp'],
+      total_length: [s[:tot], 'bp'],
+      g_c_content: [s[:gc], '%']
+    }
+  end
+
+  def compute_cds(r)
+    s = MiGA.seqs_length(r.file_path(:proteins), :fasta)
+    stats = {
+      predicted_proteins: s[:n],
+      average_length: [s[:avg], 'aa']}
+    asm = cli.load_dataset.add_result(:assembly, false)
+    unless asm.nil? or asm[:stats][:total_length].nil?
+      stats[:coding_density] =
+        [300.0 * s[:tot] / asm[:stats][:total_length][0], '%']
+    end
+    stats
+  end
+
+  def compute_essential_genes(r)
+    stats = {}
+    d = cli.load_dataset
+    if d.is_multi?
+      stats = {median_copies: 0, mean_copies: 0}
+      File.open(r.file_path(:report), 'r') do |fh|
+        fh.each_line do |ln|
+          if /^! (Mean|Median) number of copies per model: (.*)\./.match(ln)
+            stats["#{$1.downcase}_copies".to_sym] = $2.to_f
+          end
+        end
+      end
+    else
+      # Fix estimate for Archaea
+      if !d.metadata[:tax].nil? &&
+            d.metadata[:tax].in?(Taxonomy.new('d:Archaea')) &&
+            r.file_path(:bac_report).nil?
+        scr = "#{MiGA.root_path}/utils/arch-ess-genes.rb"
+        rep = r.file_path(:report)
+        rc_p = File.expand_path('.miga_rc', ENV['HOME'])
+        rc = File.exist?(rc_p) ? ". '#{rc_p}' && " : ''
+        $stderr.print `#{rc} ruby '#{scr}' '#{rep}' '#{rep}.archaea'`
+        r.add_file(:bac_report, "#{d.name}.ess/log")
+        r.add_file(:report, "#{d.name}.ess/log.archaea")
+      end
+      # Extract/compute quality values
+      stats = {completeness: [0.0, '%'], contamination: [0.0, '%']}
+      File.open(r.file_path(:report), 'r') do |fh|
+        fh.each_line do |ln|
+          if /^! (Completeness|Contamination): (.*)%/.match(ln)
+            stats[$1.downcase.to_sym][0] = $2.to_f
+          end
+        end
+      end
+      stats[:quality] = stats[:completeness][0] - stats[:contamination][0] * 5
+      d.metadata[:quality] = case stats[:quality]
+        when 80..100 ; :excellent
+        when 50..80  ; :high
+        when 20..50  ; :intermediate
+        else         ; :low
+      end
+      d.save
+    end
+    stats
+  end
+
+  def compute_ssu(r)
+    stats = {ssu: 0, complete_ssu: 0}
+    Zlib::GzipReader.open(r.file_path(:gff)) do |fh|
+      fh.each_line do |ln|
+        next if ln =~ /^#/
+        rl = ln.chomp.split("\t")
+        len = (rl[4].to_i - rl[3].to_i).abs + 1
+        stats[:max_length] = [stats[:max_length] || 0, len].max
+        stats[:ssu] += 1
+        stats[:complete_ssu] += 1 unless rl[8] =~ /\(partial\)/
+      end
+    end
+    stats
+  end
+
+  def compute_taxonomy(r)
+    stats = {}
+    File.open(r.file_path(:intax_test), 'r') do |fh|
+      fh.gets.chomp =~ /Closest relative: (\S+) with AAI: (\S+)\.?/
+      stats[:closest_relative] = $1
+      stats[:aai] = [$2.to_f, '%']
+      3.times { fh.gets }
+      fh.each_line do |ln|
+        row = ln.chomp.gsub(/^\s*/,'').split(/\s+/)
+        break if row.empty?
+        stats[:"#{row[0]}_pvalue"] = row[2].to_f unless row[0] == 'root'
+      end
+    end
+    stats
+  end
 end

data/lib/miga/cli/action/summary.rb

@@ -11,18 +11,22 @@ class MiGA::Cli::Action::Summary < MiGA::Cli::Action
       cli.opt_object(opt, [:project, :dataset_opt])
       cli.opt_filter_datasets(opt)
       cli.opt_object(opt, [:result_dataset])
+      opt.on(
+        '-o', '--output PATH',
+        'Create output file instead of returning to STDOUT'
+      ) { |v| cli[:output] = v }
       opt.on(
         '--tab',
         'Return a tab-delimited table'
-        ){ |v| cli[:tabular] = v }
+      ) { |v| cli[:tabular] = v }
       opt.on(
         '--key STRING',
         'Return only the value of the requested key'
-        ){ |v| cli[:key_md] = v }
+      ) { |v| cli[:key_md] = v }
       opt.on(
         '--with-units',
         'Include units in each cell'
-        ){ |v| cli[:units] = v }
+      ) { |v| cli[:units] = v }
     end
   end
 
@@ -44,6 +48,8 @@ class MiGA::Cli::Action::Summary < MiGA::Cli::Action
       stats.map{ |s| keys.
         map{ |k| s[k].is_a?(Array) ? s[k].map(&:to_s).join('') : s[k] } } :
       stats.map{ |s| keys.map{ |k| s[k].is_a?(Array) ? s[k].first : s[k] } }
-    cli.puts MiGA.tabulate(keys, table, cli[:tabular])
+    io = cli[:output].nil? ? $stdout : File.open(cli[:output], 'w')
+    cli.puts(io, MiGA.tabulate(keys, table, cli[:tabular]))
+    io.close unless cli[:output].nil?
   end
 end

data/lib/miga/cli/action/tax_dist.rb

@@ -25,6 +25,23 @@ class MiGA::Cli::Action::TaxDist < MiGA::Cli::Action
   end
 
   def perform
+    dist = read_distances
+    Dir.mktmpdir do |dir|
+      tab = get_tab_index(dir)
+      dist = traverse_taxonomy(tab, dist)
+    end
+
+    cli.say 'Generating report'
+    dist.keys.each do |k|
+      dist[k][5] = dist[k][4].reverse.join(' ')
+      dist[k][4] = dist[k][4].first
+      puts (k.split('-') + dist[k]).join("\t")
+    end
+  end
+
+  private
+
+  def read_distances
     p = cli.load_project
     metric = p.is_clade? ? 'ani' : 'aai'
     res_n  = "#{metric}_distances"
@@ -44,59 +61,57 @@ class MiGA::Cli::Action::TaxDist < MiGA::Cli::Action
     end
     cli.say "  Lines: #{mfh.lineno}"
     mfh.close
+    dist
+  end
 
-    Dir.mktmpdir do |dir|
-      if cli[:index].nil?
-        ds = cli.load_and_filter_datasets
-        ds.keep_if { |d| !d.metadata[:tax].nil? }
+  def get_tab_index(dir)
+    if cli[:index].nil?
+      ds = cli.load_and_filter_datasets
+      ds.keep_if { |d| !d.metadata[:tax].nil? }
 
-        cli.say 'Indexing taxonomy'
-        tax_index = TaxIndex.new
-        ds.each { |d| tax_index << d }
-        tab = File.expand_path('index.tab', dir)
-        File.open(tab, 'w') { |fh| fh.print tax_index.to_tab }
-      else
-        tab = cli[:index]
-      end
+      cli.say 'Indexing taxonomy'
+      tax_index = TaxIndex.new
+      ds.each { |d| tax_index << d }
+      tab = File.expand_path('index.tab', dir)
+      File.open(tab, 'w') { |fh| fh.print tax_index.to_tab }
+    else
+      tab = cli[:index]
+    end
+    tab
+  end
 
-      cli.say 'Traversing taxonomy'
-      rank_i = 0
-      Taxonomy.KNOWN_RANKS.each do |rank|
-        cli.say "o #{rank}: "
-        rank_n = 0
-        rank_i += 1
-        in_rank = nil
-        ds_name = []
-        File.open(tab, 'r') do |fh|
-          fh.each_line do |ln|
-            if ln =~ /^ {#{(rank_i-1)*2}}\S+:\S+:/
-              in_rank = nil
-              ds_name = []
-            elsif ln =~ /^ {#{rank_i*2}}(#{rank}:(\S+)):/
-              in_rank = $2 == '?' ? nil : $1
-              ds_name = []
-            elsif ln =~ /^ *# (\S+)/ and not in_rank.nil?
-              ds_i = $1
-              ds_name << ds_i
-              ds_name.each do |ds_j|
-                k = cannid(ds_i, ds_j)
-                next if dist[k].nil?
-                rank_n += 1
-                dist[k][3] = rank_i
-                dist[k][4].unshift in_rank
-              end
+  def traverse_taxonomy(tab, dist)
+    cli.say 'Traversing taxonomy'
+    rank_i = 0
+    Taxonomy.KNOWN_RANKS.each do |rank|
+      cli.say "o #{rank}: "
+      rank_n = 0
+      rank_i += 1
+      in_rank = nil
+      ds_name = []
+      File.open(tab, 'r') do |fh|
+        fh.each_line do |ln|
+          if ln =~ /^ {#{(rank_i-1)*2}}\S+:\S+:/
+            in_rank = nil
+            ds_name = []
+          elsif ln =~ /^ {#{rank_i*2}}(#{rank}:(\S+)):/
+            in_rank = $2 == '?' ? nil : $1
+            ds_name = []
+          elsif ln =~ /^ *# (\S+)/ and not in_rank.nil?
+            ds_i = $1
+            ds_name << ds_i
+            ds_name.each do |ds_j|
+              k = cannid(ds_i, ds_j)
+              next if dist[k].nil?
+              rank_n += 1
+              dist[k][3] = rank_i
+              dist[k][4].unshift in_rank
             end
           end
         end
-        cli.say "#{rank_n} pairs of datasets"
       end
+      cli.say "#{rank_n} pairs of datasets"
     end
-
-    cli.say 'Generating report'
-    dist.keys.each do |k|
-      dist[k][5] = dist[k][4].reverse.join(' ')
-      dist[k][4] = dist[k][4].first
-      puts (k.split('-') + dist[k]).join("\t")
-    end
+    dist
   end
 end