bio-ngs 0.4.2.alpha.01 → 0.4.4.alpha.01

data/lib/tasks/bwa.thor

@@ -10,117 +10,43 @@
 
 class Bwa < Thor
   
-  class Index < Bwa
-	  
-	  desc "short [FASTA]", "Make the BWT index for a SHORT FASTA database"
-	  method_option :colorspace, :type => :boolean, :desc => "Index in Colorspace" 
-	  method_option :prefix, :type => :string, :desc => "Database index name"
-	  def short(fasta)
-	    real_prefix = (options[:prefix]) ? options[:prefix] : fasta
-  	  Bio::BWA.make_index(:file_in => fasta, :c => options[:colorspace], :prefix => real_prefix)
-	  end
-	
-	  desc "long [FASTA]", "Make the BWT index for a LONG FASTA database"
-	  method_option :colorspace, :type => :boolean, :desc => "Index in Colorspace" 
-	  method_option :prefix, :type => :string, :desc => "Database index name"
-	  def long(fasta)
-      real_prefix = (options[:prefix]) ? options[:prefix] : fasta
-	    Bio::BWA.make_index(:file_in => fasta, :a => "bwtsw",:c => options[:colorspace], :prefix => real_prefix)
-    end
-      
+  desc "index [FASTA]", "Create BWA index"
+  Bio::Ngs::Bwa::Index.new.thor_task(self, :index) do |wrapper, task, file_in|
+    wrapper.params = task.options
+    puts wrapper.run :arguments => [file_in]
+  end
+
+  desc "aln [PREFIX] [FASTA/Q]", "Run BWA aln (short reads)"
+  Bio::Ngs::Bwa::Aln.new.thor_task(self, :aln) do |wrapper, task, prefix, file_in|
+    wrapper.params = task.options
+    puts wrapper.run :arguments => [prefix,file_in]
   end
   
+  desc "samse [PREFIX] [SAI FILE] [FASTA/Q FILE]", "Run BWA SAM Single End conversion"
+  Bio::Ngs::Bwa::Samse.new.thor_task(self, :samse) do |wrapper, task, prefix, sai_in, file_in|
+    wrapper.params = task.options
+    puts wrapper.run :arguments => [prefix,sai_in,file_in]
+  end
   
-  class Aln < Bwa
-    
-    desc "short [FASTQ]", "Run the aligment for SHORT query sequences"
-    method_option :file_out, :type => :string, :desc => "file to write output to instead of stdout", :required => true    
-    method_option :prefix, :type => :string, :desc => "Database prefix", :required => true  
-    method_option :n, :type => :numeric, :desc => "max #diff (int) or missing prob under 0.02 err rate (float) [0.04]"
-    method_option :o, :type => :numeric, :desc => "maximum number or fraction of gap opens [1]"
-    method_option :e, :type => :numeric, :desc => "maximum number of gap extensions, -1 for disabling long gaps [-1]"
-    method_option :i, :type => :numeric, :desc => "do not put an indel within INT bp towards the ends [5]"
-    method_option :d, :type => :numeric, :desc => "maximum occurrences for extending a long deletion [10]"
-    method_option :l, :type => :numeric, :desc => "seed length [32]"
-    method_option :k, :type => :numeric, :desc => "maximum differences in the seed [2]"
-    method_option :m, :type => :numeric, :desc => "maximum entries in the queue [2000000]"
-    method_option :t, :type => :numeric, :desc => "number of threads [1]"
-    method_option :M, :type => :numeric, :desc => "mismatch penalty [3]"
-    method_option :O, :type => :numeric, :desc => "gap open penalty [11]"
-    method_option :E, :type => :numeric, :desc => "gap extension penalty [4]"
-    method_option :R, :type => :numeric, :desc => "stop searching when there are >INT equally best hits [30]"
-    method_option :q, :type => :numeric, :desc => "quality threshold for read trimming down to 35bp [0]"
-    method_option :B, :type => :numeric, :desc => "length of barcode"
-    method_option :c, :type => :boolean, :desc => "input sequences are in the color space"
-    method_option :L, :type => :boolean, :desc => "log-scaled gap penalty for long deletions"
-    method_option :N, :type => :boolean, :desc => "non-iterative mode: search for all n-difference hits"
-    method_option :I, :type => :boolean, :desc => "the input is in the Illumina 1.3+ FASTQ-like format"
-    method_option :b, :type => :boolean, :desc => "the input read file is in the BAM format"
-    method_option :single, :type => :boolean, :desc => "use single-end reads only (effective with -b)"
-    method_option :first, :type => :boolean, :desc => "use the 1st read in a pair (effective with -b)"
-    method_option :second, :type => :boolean, :desc => "use the 2nd read in a pair (effective with -b)"
-    def short(fastq)
-      bwa_options = options.dup
-      bwa_options[:file_in] = fastq
-      Bio::BWA.short_read_alignment(bwa_options.symbolize_keys)
-    end
-    
-    desc "long [FASTQ]", "Run the aligment for LONG query sequences"
-    method_option :file_out, :type => :string, :desc => "file to output results to instead of stdout", :required => true
-    method_option :prefix, :type => :string, :desc => "Database prefix", :required => true    
-    method_option :a, :type => :numeric, :desc => "score for a match [1]"
-    method_option :b, :type => :numeric, :desc => "mismatch penalty [3]"
-    method_option :q, :type => :numeric, :desc => "gap open penalty [5]"
-    method_option :r, :type => :numeric, :desc => "gap extension penalty [2]"
-    method_option :t, :type => :numeric, :desc => "number of threads [1]"
-    method_option :w, :type => :numeric, :desc => "band width [50]"
-    method_option :m, :type => :numeric, :desc => "mask level [0.50]"
-    method_option :T, :type => :numeric, :desc => "score threshold divided by a [30]"
-    method_option :s, :type => :numeric, :desc => "maximum seeding interval size [3]"
-    method_option :z, :type => :numeric, :desc => "Z-best [1]"
-    method_option :N, :type => :numeric, :desc => "seeds to trigger reverse alignment [5]"
-    method_option :c, :type => :numeric, :desc => "coefficient of length-threshold adjustment [5.5]"
-    method_option :H, :type => :boolean, :desc => "in SAM output, use hard clipping rather than soft"
-    def long(fastq)
-      bwa_options = options.dup
-      bwa_options[:file_in] = fastq
-      Bio::BWA.long_read_alignment(bwa_options.symbolize_keys)
-    end
-    
+  desc "sampe [PREFIX] [SAI-1 FILE] [SAI-2 FILE] [FASTA/Q-1 FILE] [FASTA/Q-2 FILE]", "Run BWA SAM Paired End conversion"
+  Bio::Ngs::Bwa::Sampe.new.thor_task(self, :sampe) do |wrapper, task, prefix, sai1_in, sai2_in, file1_in, file2_in|
+    wrapper.params = task.options
+    puts wrapper.run :arguments => [prefix, sai1_in, sai2_in, file1_in, file2_in]
+  end
+  
+  desc "bwasw [PREFIX] [FASTA/Q]", "Run BWA bwasw (long reads)"
+  Bio::Ngs::Bwa::Bwasw.new.thor_task(self, :bwasw) do |wrapper, task, prefix, file_in|
+    wrapper.params = task.options
+    arguments = [prefix,sai_in,file_in]
+    arguments+[task.options[:paired]] if task.options[:paired] =~/\w+/
+    puts wrapper.run :arguments => arguments
   end
 
-
-  class Sam < Bwa
-    
-    desc "single [SAI]", "Convert SAI alignment output into SAM format (single end)"
-    method_option :prefix, :type => :string, :required => true, :desc => "Database prefix"
-    method_option :fastq, :type => :string, :required => true, :desc => "FastQ file"
-    method_option :file_out, :type => :string, :required => true, :desc => "File to save the output"
-    method_options :n => :numeric, :r => :string
-    def single(sai)
-      bwa_options = options.dup
-      bwa_options[:sai] = sai
-      Bio::BWA.sai_to_sam_single(bwa_options.symbolize_keys)
-    end
-    
-    desc "paired", "Convert SAI alignment output into SAM format (paired ends)"
-    method_option :prefix, :type => :string, :required => true, :desc => "Database prefix"
-    method_option :file_out, :type => :string, :required => true, :desc => "File to save the output"
-    method_option :sai, :type => :array, :required => true, :desc => "The 2 SAI files"
-    method_option :fastq, :type => :array, :required => true, :desc => "The 2 Fasta/Q files"    
-    method_option :a, :type => :numeric, :desc => "maximum insert size [500]"
-    method_option :o, :type => :numeric, :desc => "maximum occurrences for one end [100000]"
-    method_option :n, :type => :numeric, :desc => "maximum hits to output for paired reads [3]"
-    method_option :N, :type => :numeric, :desc => "maximum hits to output for discordant pairs [10]"
-    method_option :c, :type => :numeric, :desc => "prior of chimeric rate (lower bound) [1.0e-05]"
-    method_option :r, :type => :string, :desc => "read group header line such as `@RG\tID:foo\tSM:bar' [null]"
-    method_option :P, :type => :boolean, :desc => "preload index into memory (for base-space reads only)"
-    method_option :s, :type => :boolean, :desc => "disable Smith-Waterman for the unmapped mate"
-    method_option :A, :type => :boolean, :desc => "disable insert size estimate (force -s)"
-    def paired
-      Bio::BWA.sai_to_sam_paired(options.dup.symbolize_keys)
-    end
-    
+  desc "fastmap [PREFIX] [FASTA/Q]", "Run BWA Fastmap (identify super-maximal exact matches)"
+  Bio::Ngs::Bwa::Fastmap.new.thor_task(self, :fastmap) do |wrapper, task, prefix, file_in|
+    wrapper.params = task.options
+    puts wrapper.run :arguments => [prefix,file_in]
   end
 
+
 end

data/lib/tasks/filter.thor

@@ -0,0 +1,75 @@
+class Filter < Thor
+
+  # Assume that this is a plain list of elements, with just one column. In the future it could be
+  # a table as well.
+  desc "by_list TABLE LIST", "Extract from TABLE the row with a key in LIST"
+  method_option :exclude, :type => :boolean, :aliases => '-e', :desc => "return the elements in TABLE which are not listed in LIST"
+  method_option :tablekey, :type => :numeric, :aliases => '-k', :desc =>"which field is the key to consider, start from 0"
+  method_option :listkey, :type => :numeric, :aliases => '-l', :desc =>"which field is the key to consider, start from 0"
+  method_option :delimiter, :type => :string, :default => " ", :aliases => '-d'
+  method_option :skip_table_header, :type => :boolean, :default => true, :aliases => '-h', :desc => 'Skip first line, usually the header'
+  method_option :skip_list_header, :type => :boolean, :default => true, :aliases => '-j', :desc => 'Skip first line, usually the header'
+  method_option :skip_table_lines, :type => :numeric, :aliases => '-n', :desc => 'Skip Ns line before start'
+  method_option :skip_list_lines, :type => :numeric, :aliases => '-m', :desc => 'Skip Ns line before start'
+  method_option :output, :type => :string, :aliases => '-o', :desc => 'Output results to file'
+  method_option :keep_skipped_lines, :type => :boolean, :default => false, :aliases => '-g', :desc => 'Write on output skipped lines from the TABLE file, header and number of lines skipped using option skip_table_line'
+  method_option :zero_index_system, :type => :boolean, :default => true, :aliases => '-s', :desc => 'Starts Index from ZERO ? Otherwise starts from ONE'
+  def by_list(table, list)
+  	 unless File.exists?(table)
+  	 	STDERR.puts "by_list: #{table} does not exist."
+  	 	return
+  	 end
+  	unless File.exists?(list) 
+  		STDERR.puts "by_list: #{list} does not exist."
+  		return 
+  	end
+    table_key_idx = options[:tablekey]  || 0 # by default the first element of the table.
+    list_key_idx = options[:listkey] || 0
+    #increment indexes in case the use wants to start from 1 and not from 0
+    unless options[:zero_index_system]
+      table_key_idx+=1
+      list_key_idx+=1
+    end
+    delimiter = options[:delimiter] || " " # useless it's by default a space, just for developers
+    keep_skipped_lines  = options[:keep_skipped_lines] || false
+    
+    flist = File.open(list, 'r')
+    #skip header/lines if required
+    if (nlines = options[:skip_list_lines])
+      nlines.times.each{|i| flist.readline}
+    end
+    flist.readline unless options[:skip_list_header]
+    list_dictionary = Hash.new {|hash,key| hash[key] = :fool}
+
+    flist.each_line do |line|
+    	#split row
+    	#store the list key
+    	#populate an hash wich keys 
+      list_dictionary[line.split(delimiter)[list_key_idx]]
+    end
+    flist.close
+    
+    ftable = File.open(table, 'r')
+    #skip header/lines if required
+    #keep skipped line in case it's a proprietary format 
+    skipped_lines = []
+    if (nlines = options[:skip_table_lines])
+      nlines.times.each{|i| skipped_lines << ftable.readline}
+    end
+    skipped_lines << ftable.readline unless options[:skip_table_header]
+    #list_dictionary = Hash.new {|hash,key| hash[key] = :fool}
+
+    fout = (output_name=options[:output]).nil? ? STDOUT : File.open(output_name,'w')
+    fout.puts skipped_lines if keep_skipped_lines
+    ftable.each_line do |line|
+      #search for a key in the dictionary/list 
+      if list_dictionary.key?(line.split(delimiter)[table_key_idx]) || options[:exclude]
+        fout.puts line
+      end
+    end
+    ftable.close
+    fout.close
+  end
+
+
+end

data/lib/tasks/pre.thor

@@ -1,29 +1,23 @@
 class Pre < Thor
   
-  desc "filter [DIR(s)]", "Filter the data using Y/N flag in FastQ headers (Illumina). Search for fastq.gz files within directory(ies) passed."
+  desc "illumina_filter [DIR(s)]", "Filter the data using Y/N flag in FastQ headers (Illumina). Search for fastq.gz files within directory(ies) passed."
   method_option :compression, :type => :string, :default => "pigz"
   method_option :cpu, :type => :numeric, :default => 4
-  def filter(dir)
+  def illumina_filter(dir)
     folders = Dir.glob(dir)
     cmd_blocks = []
     folders.each do |folder|
-      Dir.glob(folder+"/*.fastq.gz").sort.each do |fastq|
+      Parallel.each(Dir.glob(folder+"/*.fastq.gz").sort,:in_processes => options[:cpu].to_i) do |fastq|
         Dir.mkdir(folder+"/filtered") unless Dir.exists? folder+"/filtered"
         fastq = fastq.split("/")[-1]
-        cmd_blocks << -> {system("zcat #{folder+"/"+fastq} | grep -A 3 '^@.* [^:]*:N:[^:]*:' | grep -v '^\-\-'| #{options[:compression]} > #{folder}/filtered/#{fastq}")}
-        if cmd_blocks == options[:cpu]
-          Bio::Ngs::Utils.parallel_exec(cmd_blocks)
-          cmd_blocks = []
-        end
+        system("zcat #{folder+"/"+fastq} | grep -A 3 '^@.* [^:]*:N:[^:]*:' | grep -v '^\-\-'| #{options[:compression]} > #{folder}/filtered/#{fastq}")
       end
     end
-    Bio::Ngs::Utils.parallel_exec(cmd_blocks)
   end
   
   
   desc "merge [file(s)]","Merge together fastQ files (accepts wildcards)"
   method_option :compressed, :type => :boolean, :default => true
-  method_option :cpu, :type => :numeric, :default => 4
   def merge(file)
     files = Dir.glob(file).sort
     cat = (options[:compressed]) ? "zcat" : "cat"
@@ -37,18 +31,17 @@ class Pre < Thor
   def paired_merge(file)
     files = Dir.glob(file).sort.find_all {|f| f=~/_R1_/}
     cat = (options[:compressed] == true) ? "zcat" : "cat"
-    files.each do |file|
-      r1 = file
-      r2 = file.gsub(/_R1_/,"_R2_")
+    files.each do |r1|
+      r2 = r1.gsub(/_R1_/,"_R2_")
       if File.exists? r2
         r1_count = count_reads(r1,compressed:options[:compressed])
         r2_count = count_reads(r2,compressed:options[:compressed])
         puts "Read count: #{r1_count} : #{r2_count} , #{file}"
           if r1_count == r2_count
-            blocks = []
-            blocks << -> {system("#{cat} #{r1} >> R1_reads.fastq")}
-            blocks << -> {system("#{cat} #{r2} >> R2_reads.fastq")}
-            Bio::Ngs::Utils.parallel_exec(blocks)
+            Parallel.each(["R1","R2"],:in_processes => options[:cpu].to_i) do |read|
+              filename = (read == "R1") ? r1 : r2
+              system "#{cat} #{filename} >> #{read}_reads.fastq"
+            end
           else
             raise RuntimeError "Error: files #{r1} and #{r2} do not have the same number of reads!"
           end
@@ -64,26 +57,21 @@ class Pre < Thor
   def uncompress(file)
     files = Dir.glob(file).sort
     blocks = []
-    files.each do |file|
-      blocks << -> {system("gunzip #{file}")}
-      if blocks.size == options[:cpu]
-        Bio::Ngs::Utils.parallel_exec(blocks)
-        blocks = []
-      end
+    Parallel.each(files,:in_processes => options[:cpu].to_i) do |file|
+      system("gunzip #{file}")
     end
-    Bio::Ngs::Utils.parallel_exec(blocks) 
   end
   
   
-  desc "trim [file(s)]","Calulate quality profile and trim the all the reads using FastX (accepts wildcards)"
+  desc "trim [fastq(s)]","Calulate quality profile and trim the all the reads using FastX (accepts wildcards)"
   method_option :cpu, :type => :numeric, :default => 4
   method_option :min_qual, :type => :numeric, :default => 20
   def trim(file)
-    files = Dir.glob(file).sort
+    list = Dir.glob(file).sort
+    groups = list / options[:cpu].to_i # get group of files equal to number of CPUs
     cmd_blocks = []
-    files.each do |file|
-      
-      block = -> do
+    groups.each do |files|
+      Parallel.each(files, :in_processes => options[:cpu].to_i) do |file|
         invoke "quality:fastq_stats", [file], {output:file+".stats"}
         trim_position = options[:read_length]
         lines = File.read(file+".stats").split("\n")
@@ -109,15 +97,7 @@ class Pre < Thor
           trim.run
         end
       end
-      
-      cmd_blocks << block
-      
-      if cmd_blocks.size == options[:cpu]
-        Bio::Ngs::Utils.parallel_exec(cmd_blocks)
-        cmd_blocks = []
-      end
     end
-    Bio::Ngs::Utils.parallel_exec(cmd_blocks)
   end
   
   private

data/lib/tasks/project.thor

@@ -20,7 +20,8 @@ class Project < Thor
   method_option :type, :type => :string, :desc => "The project type (e.g. annotation)"
   def new(name)
     empty_directory name
-    empty_directory File.join("#{name}","data")
+    empty_directory File.join("#{name}","raw_data")
+    empty_directory File.join("#{name}","outputs")
     empty_directory File.join("#{name}","tasks")
     empty_directory File.join("#{name}","scripts")
     self.name = name # for template to take the correct values

data/lib/tasks/quality.thor

@@ -45,19 +45,32 @@ class Quality < Thor
   desc "fastq_stats FASTQ", "Reports quality of FASTQ file"
   method_option :output, :type=>:string, :aliases =>"-o", :desc => "Output file name. default is input file_name with .txt."
   def fastq_stats(fastq)
-    output_file = options.output || "#{fastq}.txt"
+
+    output_file = options.output || "#{fastq.gsub(/\.fastq\.gz/,'')}_stats.txt"
     stats = Bio::Ngs::Fastx::FastqStats.new
-    stats.params = {input:fastq, output:output_file}
+    if fastq=~/\.gz/
+      stats.params = {output:output_file}
+      stats.pipe_ahead=["zcat", fastq]
+    else
+      stats.params = {input:fastq, output:output_file}
+    end
     stats.run
-    invoke :boxplot, [output_file]
-    invoke :reads_coverage, [output_file]
+    require 'parallel'
+    go_in_parallel = [[:boxplot,[output_file]],
+                      [:reads_coverage,[output_file]],
+                      [:nucleotide_distribution,[output_file]]]
+    Parallel.map(go_in_parallel, in_processes:go_in_parallel.size) do |graph|
+      invoke graph.first, graph.last
+    end
+    #invoke :boxplot, [output_file]
+    #invoke :reads_coverage, [output_file]
   end
   
   desc "boxplot FASTQ_QUALITY_STATS", "plot reads quality as boxplot"
   method_option :title, :type=>:string, :aliases =>"-t", :desc  => "Title (usually the solexa file name) - will be plotted on the graph."
   method_option :output, :type=>:string, :aliases =>"-o", :desc => "Output file name. default is input file_name with .txt."
   def boxplot(fastq_quality_stats)
-    output_file = options.output || "#{fastq_quality_stats}.png"
+    output_file = options.output || "#{fastq_quality_stats}_boxplot.png"
     boxplot = Bio::Ngs::Fastx::ReadsBoxPlot.new
     boxplot.params={input:fastq_quality_stats, output:output_file}
     boxplot.run
@@ -74,6 +87,15 @@ class Quality < Thor
     coverage.run
   end
   
+  desc "nucleotide_distribution FASTQ_QUALITY_STATS", "plot reads quality as boxplot"
+  method_option :title, :type=>:string, :aliases =>"-t", :desc  => "Title (usually the solexa file name) - will be plotted on the graph."
+  method_option :output, :type=>:string, :aliases =>"-o", :desc => "Output file name. default is input file_name with .txt."
+  def nucleotide_distribution(fastq_quality_stats)
+    output_file = options.output || "#{fastq_quality_stats}_nuc_dist.png"
+    nucdistr = Bio::Ngs::Fastx::NucleotideDistribution.new
+    nucdistr.params={input:fastq_quality_stats, output:output_file}
+    nucdistr.run
+  end
 
   desc "illumina_b_profile_raw FASTQ", "perform a profile for reads coming fom Illumina 1.5+ and write the report in a txt file"
   method_option :read_length, :type => :numeric, :required => true

data/lib/wrapper.rb

@@ -42,6 +42,7 @@ module Bio
         @program = binary || self.class.program
         @options = options
         @params = {}
+        @pipe_ahead = []
       end
 
       # Parameters are accepted ONLY if the key is present as
@@ -73,6 +74,27 @@ module Bio
         @params.clear
       end
 
+
+      def pipe_ahead
+        # TODO: recursive call to other Bio::Ngs wrapped commands
+        @pipe_ahead
+      end
+
+      def pipe_ahead?
+        return !@pipe_ahead.empty?
+      end
+
+      # If setted is an array described like the ones in Open3.pipeline
+      # http://www.ruby-doc.org/stdlib-1.9.3/libdoc/open3/rdoc/Open3.html#method-c-pipeline
+      def pipe_ahead=(ary)
+        @pipe_ahead=ary || []
+      end
+
+      #Return an array of elements of the command line
+      def to_cmd_ary(opts={arguments:[],separator:"="})
+        [program, sub_program, normalize_params(opts[:separator]), opts[:arguments]].flatten.compact
+      end
+
       # Return the options and parameters formmatted as typed in the command line as a string
       # opts[:separator] is important not all the applications require a "=" for separating options and values
       # TODO: need to be compliant with Bio::Command ?
@@ -130,8 +152,8 @@ module Bio
           raise "Can't write to any output file. With a program which writes on stdout you must provide a file name" if opts[:output_file].nil?
           file_stdlog = File.open(opts[:output_file], 'w')
           file_errlog = File.open(opts[:output_file]+".err",'w')
-
-          Bio::Command.call_command_open3([program, sub_program, normalize_params(opts[:separator]), opts[:arguments]].flatten.compact) do |pin, pout, perr|
+          #[program, sub_program, normalize_params(opts[:separator]), opts[:arguments]].flatten.compact
+          Bio::Command.call_command_open3(to_cmd_ary(separator:opts[:separator], arguments:opts[:arguments])) do |pin, pout, perr|
             pout.sync = true
             perr.sync = true           
             t = Thread.start {pout.lines{|line| file_stdlog.puts line}}
@@ -143,12 +165,17 @@ module Bio
           end #command call open3
           file_stdlog.close
           file_errlog.close
+
+        elsif pipe_ahead?
+          #in case the user setted the pipeline we use it.
+          Open3.pipeline(pipe_ahead, to_cmd_ary(separator:opts[:separator], arguments:opts[:arguments]))
         else
           # puts "Normlized #{normalize_params(opts[:separator])}"
           # puts "Arguments #{opts[:arguments]}"
-#puts [program, sub_program, normalize_params(opts[:separator]), opts[:arguments]].flatten.compact.inspect
-
-        Bio::Command.query_command([program, sub_program, normalize_params(opts[:separator]), opts[:arguments]].flatten.compact)
+          #puts [program, sub_program, normalize_params(opts[:separator]), opts[:arguments]].flatten.compact.inspect
+        #Note: maybe seprator could be defined as a method  for each wrapped program ?
+        Bio::Command.query_command(to_cmd_ary(separator:opts[:separator], arguments:opts[:arguments]))
+        #[program, sub_program, normalize_params(opts[:separator]), opts[:arguments]].flatten.compact
         end #if
       end #run