miga-base 0.7.23.0 → 0.7.25.3

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

@@ -21,18 +21,20 @@ class MiGA::Cli::Action::PreprocWf < MiGA::Cli::Action
         '-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)
+      opts_for_wf(
+        opt, 'Input files as defined by --input-type',
+        multi: true, cleanup: false, ncbi: false, project_type: true
+      )
     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] }
+    norun = %w[
+      project_stats haai_distances aai_distances ani_distances clade_finding
     ]
+    p_metadata = Hash[norun.map { |i| ["run_#{i}", false] }]
     d_metadata = { run_distances: false }
     unless cli[:mytaxa]
       d_metadata[:run_mytaxa_scan] = false

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

@@ -21,10 +21,10 @@ class MiGA::Cli::Action::QualityWf < MiGA::Cli::Action
 
   def perform
     # Input data
-    p_metadata = Hash[
-      %w[project_stats haai_distances aai_distances ani_distances clade_finding]
-                 .map { |i| ["run_#{i}", false] }
+    norun = %w[
+      project_stats haai_distances aai_distances ani_distances clade_finding
     ]
+    p_metadata = Hash[norun.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)

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

@@ -47,7 +47,7 @@ class MiGA::Cli::Action::TaxDist < MiGA::Cli::Action
 
   def read_distances
     p = cli.load_project
-    cli[:metric] ||= p.is_clade? ? 'ani' : 'aai'
+    cli[:metric] ||= p.clade? ? 'ani' : 'aai'
     res_n = "#{cli[:metric]}_distances"
     cli.say "Reading distances: 1-#{cli[:metric].upcase}"
     res = p.result(res_n)

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

@@ -59,7 +59,7 @@ class MiGA::Cli::Action::TaxTest < MiGA::Cli::Action
     cli.puts "Closest relative: #{cr[0]} with AAI: #{cr[1]}."
     p = cli.load_project
     if cli[:ref_project]
-      if (ref = p.metadata[:ref_project]).nil?
+      if (ref = p.option(:ref_project)).nil?
         raise '--ref-project requested but no reference project has been set'
       end
       if (q = MiGA::Project.load(ref)).nil?

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

@@ -7,9 +7,8 @@ module MiGA::Cli::Action::Wf
   def default_opts_for_wf
     cli.expect_files = true
     cli.defaults = {
-      clean: false, regexp: MiGA::Cli.FILE_REGEXP,
-      project_type: :genomes, dataset_type: :popgenome,
-      ncbi_draft: true, min_qual: 25.0
+      clean: false, project_type: :genomes, dataset_type: :popgenome,
+      ncbi_draft: true, min_qual: MiGA::Project.OPTIONS[:min_qual][:default]
     }
   end
 
@@ -56,28 +55,10 @@ module MiGA::Cli::Action::Wf
     opt.on(
       '-R', '--name-regexp REGEXP', Regexp,
       'Regular expression indicating how to extract the name from the path',
-      "By default: '#{cli[:regexp]}'"
+      "By default: '#{MiGA::Cli.FILE_REGEXP}'"
     ) { |v| cli[:regexp] = v }
-    opt.on(
-      '--type STRING',
-      "Type of datasets. By default: #{cli[:dataset_type]}",
-      'Recognized types:',
-      *MiGA::Dataset.KNOWN_TYPES
-        .map do |k, v|
-          "~ #{k}: #{v[:description]}" unless !params[:multi] && v[:multi]
-        end.compact
-    ) { |v| cli[:dataset_type] = v.downcase.to_sym }
-    if params[:project_type]
-      opt.on(
-        '--project-type STRING',
-        "Type of project. By default: #{cli[:project_type]}",
-        'Recognized types:',
-        *MiGA::Project.KNOWN_TYPES
-          .map do |k, v|
-            "~ #{k}: #{v[:description]}" unless !params[:multi] && v[:multi]
-          end.compact
-      ) { |v| cli[:project_type] = v.downcase.to_sym }
-    end
+    opt_object_type(opt, :dataset, params[:multi])
+    opt_object_type(opt, :project, params[:multi]) if params[:project_type]
     opt.on(
       '--daemon PATH',
       'Use custom daemon configuration in JSON format',
@@ -106,7 +87,7 @@ module MiGA::Cli::Action::Wf
     end
     opt.on(
       '--haai-p STRING',
-      'hAAI search engine. One of: blast+ (default), blat, diamond, no'
+      'hAAI search engine. One of: blast+ (default), fastaai, blat, diamond, no'
     ) { |v| cli[:haai_p] = v }
     opt.on(
       '--aai-p STRING',
@@ -124,33 +105,42 @@ module MiGA::Cli::Action::Wf
       project_type: '--project-type',
       dataset_type: '--dataset-type'
     )
+    paired = cli[:input_type].to_s.include?('_paired')
+    cli[:regexp] ||= MiGA::Cli.FILE_REGEXP(paired)
+
     # Create empty project
-    call_cli([
-               'new',
-               '-P', cli[:outdir],
-               '-t', cli[:project_type]
-             ]) unless MiGA::Project.exist? cli[:outdir]
+    call_cli(
+      ['new', '-P', cli[:outdir], '-t', cli[:project_type]]
+    ) unless MiGA::Project.exist? cli[:outdir]
+
     # Define project metadata
     p = cli.load_project(:outdir, '-o')
-    %i[haai_p aai_p ani_p ess_coll min_qual].each { |i| p_metadata[i] = cli[i] }
     p_metadata[:type] = cli[:project_type]
     transfer_metadata(p, p_metadata)
+    %i[haai_p aai_p ani_p ess_coll min_qual].each do |i|
+      p.set_option(i, cli[i])
+    end
+
     # Download datasets
-    call_cli([
-               'ncbi_get',
-               '-P', cli[:outdir],
-               '-T', cli[:ncbi_taxon],
-               (cli[:ncbi_draft] ? '--all' : '--complete')
-             ]) unless cli[:ncbi_taxon].nil?
+    unless cli[:ncbi_taxon].nil?
+      what = cli[:ncbi_draft] ? '--all' : '--complete'
+      call_cli(
+        ['ncbi_get', '-P', cli[:outdir], '-T', cli[:ncbi_taxon], what]
+      )
+    end
+
     # Add datasets
-    call_cli([
-      'add',
-      '--ignore-dups',
-      '-P', cli[:outdir],
-      '-t', cli[:dataset_type],
-      '-i', stage,
-      '-R', cli[:regexp]
-    ] + cli.files) unless cli.files.empty?
+    call_cli(
+      [
+        'add',
+        '--ignore-dups',
+        '-P', cli[:outdir],
+        '-t', cli[:dataset_type],
+        '-i', stage,
+        '-R', cli[:regexp]
+      ] + cli.files
+    ) unless cli.files.empty?
+
     # Define datasets metadata
     p.load
     d_metadata[:type] = cli[:dataset_type]
@@ -161,13 +151,13 @@ module MiGA::Cli::Action::Wf
   def summarize(which = %w[cds assembly essential_genes ssu])
     which.each do |r|
       cli.say "Summary: #{r}"
-      call_cli([
-                 'summary',
-                 '-P', cli[:outdir],
-                 '-r', r,
-                 '-o', File.expand_path("#{r}.tsv", cli[:outdir]),
-                 '--tab', '--ref', '--active'
-               ])
+      call_cli(
+        [
+          'summary',
+          '-P', cli[:outdir], '-r', r, '--tab', '--ref', '--active',
+          '-o', File.join(cli[:outdir], "#{r}.tsv")
+        ]
+      )
     end
     call_cli(['browse', '-P', cli[:outdir]])
   end
@@ -193,17 +183,45 @@ module MiGA::Cli::Action::Wf
     cmd += ['--max-jobs', cli[:jobs]] unless cli[:jobs].nil?
     cmd += ['--ppn', cli[:threads]] unless cli[:threads].nil?
     cwd = Dir.pwd
-    call_cli cmd
+    call_cli(cmd)
     Dir.chdir(cwd)
   end
 
   def transfer_metadata(obj, md)
     # Clear old metadata
     obj.metadata.each do |k, v|
-      obj.metadata[k] = nil if k.to_s =~ /^run_/ || k == :ref_project
+      obj.metadata[k] = nil if k.to_s =~ /^run_/ || obj.option?(k)
     end
     # Transfer and save
     md.each { |k, v| obj.metadata[k] = v }
     obj.save
   end
+
+  private
+
+  ##
+  # Add option --type or --project-type to +opt+
+  def opt_object_type(opt, obj, multi)
+    conf =
+      case obj
+      when :dataset
+        ['type', 'datasets', :dataset_type, MiGA::Dataset]
+      when :project
+        ['project-type', 'project', :project_type, MiGA::Project]
+      else
+        raise "Unrecognized object type: #{obj}"
+      end
+
+    options =
+      conf[3].KNOWN_TYPES.map do |k, v|
+        "~ #{k}: #{v[:description]}" unless !multi && v[:multi]
+      end.compact
+
+    opt.on(
+      "--#{conf[0]} STRING",
+      "Type of #{conf[1]}. By default: #{cli[conf[2]]}",
+      'Recognized types:',
+      *options
+    ) { |v| cli[conf[2]] = v.downcase.to_sym }
+  end
 end

data/lib/miga/cli/base.rb

@@ -34,6 +34,7 @@ module MiGA::Cli::Base
     next_step: 'Return the next task to run in a dataset or project',
     # Objects (Datasets or Projects)
     edit: 'Edit the metadata of a dataset or project',
+    option: 'Get or set options of a dataset or project',
     # System
     init: 'Initialize MiGA to process new projects',
     daemon: 'Control the daemon of a MiGA project',
@@ -87,19 +88,30 @@ module MiGA::Cli::Base
   @@EXECS = @@TASK_DESC.keys
 
   @@FILE_REGEXP =
-    %r{^(?:.*/)?(.+?)(\.[A-Z]*([12]|Reads|Contigs))?(\.f[nastq]+)?$}i
+    %r{^(?:.*/)?(.+?)(\.[A-Z]*(Reads|Contigs))?(\.f[nastq]+)?(\.gz)?$}i
+
+  @@PAIRED_FILE_REGEXP =
+    %r{^(?:.*/)?(.+?)(\.[A-Z]*([12]|Reads))?(\.f[nastq]+)?(\.gz)?$}i
 end
 
 class MiGA::Cli < MiGA::MiGA
   include MiGA::Cli::Base
 
   class << self
-    def TASK_DESC; @@TASK_DESC end
+    def TASK_DESC
+      @@TASK_DESC
+    end
 
-    def TASK_ALIAS; @@TASK_ALIAS end
+    def TASK_ALIAS
+      @@TASK_ALIAS
+    end
 
-    def EXECS; @@EXECS end
+    def EXECS
+      @@EXECS
+    end
 
-    def FILE_REGEXP; @@FILE_REGEXP end
+    def FILE_REGEXP(paired = false)
+      paired ? @@PAIRED_FILE_REGEXP : @@FILE_REGEXP
+    end
   end
 end

data/lib/miga/cli/objects_helper.rb

@@ -57,12 +57,12 @@ module MiGA::Cli::ObjectsHelper
     ds.select! do |d|
       advance('Datasets:', k += 1, n, false)
       o = true
-      o &&= (d.is_ref? == self[:ref]) unless self[:ref].nil?
-      o &&= (d.is_active? == self[:active]) unless self[:active].nil?
-      o &&= (self[:multi] ? d.is_multi? :
-            d.is_nonmulti?) unless self[:multi].nil?
-      o &&= (not d.metadata[:tax].nil?) &&
-            d.metadata[:tax].in?(self[:taxonomy]) unless self[:taxonomy].nil?
+      o &&= (d.ref? == self[:ref]) unless self[:ref].nil?
+      o &&= (d.active? == self[:active]) unless self[:active].nil?
+      o &&= (self[:multi] ? d.multi? : d.nonmulti?) unless self[:multi].nil?
+      unless self[:taxonomy].nil?
+        o &&= !d.metadata[:tax].nil? && d.metadata[:tax].in?(self[:taxonomy])
+      end
       o
     end
     say ''
@@ -90,22 +90,27 @@ module MiGA::Cli::ObjectsHelper
   def add_metadata(obj, cli = self)
     raise "Unsupported object: #{obj.class}" unless obj.respond_to? :metadata
 
-    cli[:metadata].split(',').each do |pair|
+    (cli[:metadata] || '').split(',').each do |pair|
       (k, v) = pair.split('=')
-      case v
-      when 'true';  v = true
-      when 'false'; v = false
-      when 'nil';   v = nil
-      end
-      if k == '_step'
-        obj.metadata["_try_#{v}"] ||= 0
-        obj.metadata["_try_#{v}"]  += 1
+      if obj.option?(k)
+        obj.set_option(k, v, true)
+      else
+        case v
+        when 'true';  v = true
+        when 'false'; v = false
+        when 'nil';   v = nil
+        end
+        if k == '_step'
+          obj.metadata["_try_#{v}"] ||= 0
+          obj.metadata["_try_#{v}"]  += 1
+        end
+        obj.metadata[k] = v
       end
-      obj.metadata[k] = v
-    end unless cli[:metadata].nil?
-    [:type, :name, :user, :description, :comments].each do |k|
+    end
+    %i[type name user description comments].each do |k|
       obj.metadata[k] = cli[k] unless cli[k].nil?
     end
+    obj.save
     obj
   end
 end

data/lib/miga/common.rb

@@ -24,7 +24,7 @@ class MiGA::MiGA
   ##
   # Has MiGA been initialized?
   def self.initialized?
-    File.exist?(File.expand_path('.miga_rc', ENV['MIGA_HOME'])) and
+    File.exist?(File.expand_path('.miga_rc', ENV['MIGA_HOME'])) &&
       File.exist?(File.expand_path('.miga_daemon.json', ENV['MIGA_HOME']))
   end
 

data/lib/miga/common/with_option.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+##
+# Helper module including specific functions to handle objects that
+# have configurable options. The class including this module must implement
+# the methods +.OPTIONS+, +#metadata+, and +#save+.
+module MiGA::Common::WithOption
+  def option(key)
+    assert_has_option(key)
+    opt = option_by_metadata(key)
+    value = opt.nil? ? option_by_default(key) : opt
+    value = value[self] if value.is_a?(Proc)
+    value
+  end
+
+  def set_option(key, value, from_string = false)
+    metadata[key] = assert_valid_option_value(key, value, from_string)
+    save
+    option(key)
+  end
+
+  def all_options
+    Hash[self.class.OPTIONS.each_key.map { |key| [key, option(key)] }]
+  end
+
+  def option?(key)
+    !self.class.OPTIONS[key.to_sym].nil?
+  end
+
+  def option_by_metadata(key)
+    metadata[key]
+  end
+
+  def option_by_default(key)
+    self.class.OPTIONS[key.to_sym][:default]
+  end
+
+  def assert_has_option(key)
+    opt = self.class.OPTIONS[key.to_sym]
+    raise "Unrecognized option: #{key}" if opt.nil?
+    opt
+  end
+
+  def assert_valid_option_value(key, value, from_string = false)
+    opt = assert_has_option(key)
+    value = option_from_string(key, value) if from_string
+
+    # nil is always valid, and so are supported tokens
+    return value if value.nil? || opt[:tokens]&.include?(value)
+
+    if opt[:type] && !value.is_a?(opt[:type])
+      raise "Invalid value type for #{key}: #{value.class}, not #{opt[:type]}"
+    end
+
+    if opt[:in] && !opt[:in].include?(value)
+      raise "Value out of range for #{key}: #{value}, not in #{opt[:in]}"
+    end
+
+    value
+  end
+
+  def option_from_string(key, value)
+    opt = assert_has_option(key)
+
+    if ['', 'nil'].include?(value)
+      nil
+    elsif opt[:tokens]&.include?(value)
+      value
+    elsif opt[:type]&.equal?(Float)
+      raise "Not a float: #{value}" unless value =~ /^-?\.?\d/
+      value.to_f
+    elsif opt[:type]&.equal?(Integer)
+      raise "Not an integer: #{value}" unless value =~ /^-?\d/
+      value.to_i
+    elsif opt[:in]&.include?(true) && value == 'true'
+      true
+    elsif opt[:in]&.include?(false) && value == 'false'
+      false
+    else
+      value
+    end
+  end
+end

data/lib/miga/common/with_result.rb

@@ -86,7 +86,8 @@ module MiGA::Common::WithResult
         if res.nil?
           # Run if the step has not been calculated,
           # unless too many attempts were already made
-          if (metadata["_try_#{t}"] || 0) > (project.metadata[:max_try] || 10)
+          cur_try = metadata["_try_#{t}"] || 0
+          if cur_try > project.option(:max_try)
             inactivate! "Too many errors in step #{t}"
             false
           else