seqtrimnext 2.0.51 → 2.0.52

data/lib/seqtrimnext/plugins/plugin.rb

@@ -15,23 +15,48 @@ class Plugin
   attr_accessor :stats
 
   #Loads the plugin's execution whit the sequence "seq"
-  def initialize(seq,params)
-    # $LOG.debug self.class.to_s + " processing sequence: " + seq.seq_name
-    # if (!(self.class.to_s=='PluginLowQuality') )
+  def initialize(seq, params)
     @params = params
     @stats ={}
-    execute(seq)
-    # puts self.class.to_s + ' PPPPPPPPPP'
-    # else
-    # $LOG.error " Quality File haven't been provided. It's impossible to execute " +self.class.to_s + seq.seq_qual.nil?.to_s
-    # end
+    
+    if can_execute?
+      execute(seq)
+    end
+    
+  end
+
+  def can_execute?
+    return true
   end
 
   #Begins the plugin's execution whit the sequence "seq"
   def execute(seqs)
+    blasts=do_blasts(seqs)
+
+    if !blasts.empty?
+      
+      if blasts.is_a?(Array)
+        queries=blasts
+      else
+        queries = blasts.querys
+      end
+      
+      seqs.each_with_index do |s,i|
+        exec_seq(s,queries[i])
+      end
+
+    else # there is no blast
 
+      seqs.each do |s|
+        exec_seq(s,nil)
+      end
+
+    end
   end
 
+  def do_blasts(seqs)
+    return []
+  end
 
   #Initializes the structure stats  to the given key and value , only when it is neccesary, and increases its counter
   def add_stats(key,value)
@@ -69,14 +94,19 @@ class Plugin
     return ((r1_start<=r2_end+1) and (r1_end>=r2_start-1) )
   end
 
-  def merge_hits(hits,merged_hits,merged_ids=nil)
+  def merge_hits(hits,merged_hits,merged_ids=nil, merge_different_ids=true)
     # puts " merging ============"
     # hits.each do |hit|
     hits.sort{|h1,h2| (h1.q_end-h1.q_beg+1)<=>(h2.q_end-h2.q_beg+1)}.reverse_each do |hit|
 
       merged_ids.push hit.definition if !merged_ids.nil? && (! merged_ids.include?(hit.definition))
       # if new hit's position is already contained in hits, then ignore the new hit
-      c=merged_hits.find{|c| overlapX?(hit.q_beg, hit.q_end,c.q_beg,c.q_end)}
+      if merge_different_ids
+        c=merged_hits.find{|c| overlapX?(hit.q_beg, hit.q_end,c.q_beg,c.q_end)}
+      else
+        # overlap with existent hit and same subject id
+        c=merged_hits.find{|c| (overlapX?(hit.q_beg, hit.q_end,c.q_beg,c.q_end) && (hit.subject_id==c.subject_id))}
+      end
       # puts " c #{c.inspect}"
 
       if (c.nil?)
@@ -89,10 +119,10 @@ class Plugin
 
         # one is inside each other, just ignore
         if ((hit.q_beg>=c.q_beg && hit.q_end <=c.q_end) || (c.q_beg>=hit.q_beg && c.q_end <= hit.q_end))
-            # puts "* #{hit.subject_id} inside #{c.subject_id}"
+          # puts "* #{hit.subject_id} inside #{c.subject_id}"
         else
           # merge with old contaminant
-                      # puts "#{hit.subject_id} NOT inside #{c.subject_id}"
+          # puts "#{hit.subject_id} NOT inside #{c.subject_id}"
           min=[c.q_beg,hit.q_beg].min
           max=[c.q_end,hit.q_end].max
 

data/lib/seqtrimnext/plugins/plugin_ab_adapters.rb

@@ -13,16 +13,9 @@ class PluginAbAdapters < Plugin
   MIN_ADAPTER_SIZE = 5
   MIN_FAR_ADAPTER_SIZE = 13
   MIN_LEFT_ADAPTER_SIZE = 9
- #Begins the plugin1's execution to warn that there are contaminants in the sequence "seq"
- def execute(seqs)
-   blasts= do_blasts(seqs)
-   
-   seqs.each_with_index do |s,i|
-     exec_seq(s,blasts.querys[i])
-   end
- end
  
  def do_blasts(seqs)
+    
     # find MIDS  with less results than max_target_seqs value 
     blast=BatchBlast.new("-db #{@params.get_param('adapters_ab_db')}",'blastn'," -task blastn-short -perc_identity #{@params.get_param('blast_percent_ab')} -word_size #{MIN_ADAPTER_SIZE}")  
     $LOG.debug('BLAST:'+blast.get_blast_cmd)

data/lib/seqtrimnext/plugins/plugin_adapters.rb

@@ -12,15 +12,6 @@ class PluginAdapters < Plugin
   # adapters found at end of sequence are even 2 nt wide, cut in 5 because of statistics
   MIN_ADAPTER_SIZE = 5
   MIN_FAR_ADAPTER_SIZE = 13
-  # MIN_LEFT_ADAPTER_SIZE = 9
- #Begins the plugin1's execution to warn that there are contaminants in the sequence "seq"
- def execute(seqs)
-   blasts= do_blasts(seqs)
-   
-   seqs.each_with_index do |s,i|
-     exec_seq(s,blasts.querys[i])
-   end
- end
  
  def do_blasts(seqs)
     # find MIDS  with less results than max_target_seqs value 

data/lib/seqtrimnext/plugins/plugin_amplicons.rb

@@ -9,18 +9,6 @@ require "plugin"
 
 class PluginAmplicons < Plugin
 
-  # adapters found at end of sequence are even 2 nt wide, cut in 5 because of statistics
-  # MIN_PRIMER_SIZE = 5
-  # MIN_FAR_ADAPTER_SIZE = 13
-  # MIN_LEFT_ADAPTER_SIZE = 9
-  #Begins the plugin1's execution to warn that there are contaminants in the sequence "seq"
-  def execute(seqs)
-    blasts= do_blasts(seqs)
-
-    seqs.each_with_index do |s,i|
-      exec_seq(s,blasts.querys[i])
-    end
-  end
 
   def do_blasts(seqs)
     # find MIDS  with less results than max_target_seqs value

data/lib/seqtrimnext/plugins/plugin_contaminants.rb

@@ -18,14 +18,6 @@ class PluginContaminants < Plugin
     max_to_extreme=(min_cont_size/2).to_i
     return ((c.q_beg-max_to_extreme<0) || (( c.q_end+max_to_extreme)>=seq.seq_fasta.size-1) ) #return if vector is very near to the extremes of insert)
   end
-  #Begins the plugin1's execution to warn that there are contaminants in the sequence "seq"
-  def execute(seqs)
-    blasts= do_blasts(seqs)
-
-    seqs.each_with_index do |s,i|
-      exec_seq(s,blasts.querys[i])
-    end
-  end
 
   def do_blasts(seqs)
     # find MIDS  with less results than max_target_seqs value
@@ -63,6 +55,11 @@ class PluginContaminants < Plugin
 
 
   def exec_seq(seq,blast_query)
+    
+    if seq.get_actions(ActionUserContaminant)
+      return
+    end
+    
     if blast_query.query_id != seq.seq_name
       # raise "Blast and seq names does not match, blast:#{blast_query.query_id} sn:#{seq.seq_name}"
     end

data/lib/seqtrimnext/plugins/plugin_extract_inserts.rb

@@ -276,16 +276,7 @@ class PluginExtractInserts < Plugin
     return sub_inserts
   end
   
-  
-  # Begins the plugin1's execution to warn that there is linker  into the sequence
- def execute(seqs)
-    seqs.each do |s|
-       exec_seq(s)
-    end
-  end
-
-
-  def exec_seq(seq)
+  def exec_seq(seq,blast_query)
      $LOG.debug "[#{self.class.to_s}, seq: #{seq.seq_name}]: extract inserts"    
           
      # puts "INSERTO ANTES LINKER INSERT:"+seq.seq_fasta

data/lib/seqtrimnext/plugins/plugin_find_poly_at.rb

@@ -232,9 +232,6 @@ class PluginFindPolyAt < Plugin
         end
 
 
-
-
-
           # if (poly['begin']<=MAX_POLY_T_FROM_LEFT*2)
           #   seq.seq_rejected=true
           #   seq.seq_rejected_by_message='polyT found'
@@ -311,14 +308,7 @@ class PluginFindPolyAt < Plugin
 
 
 
- def execute(seqs)
-   seqs.each do |s|
-       exec_seq(s)
-    end
-  end
-
-
-  def exec_seq(seq)
+  def exec_seq(seq,blast_query)
     $LOG.debug "[#{self.class.to_s}, seq: #{seq.seq_name}]: looking for strings of polyAT's into the sequence with a length indicated by the param <poly_at_length>"
 
     find_polyT(seq)

data/lib/seqtrimnext/plugins/plugin_ignore_repeated.rb

@@ -13,14 +13,8 @@ class PluginIgnoreRepeated < Plugin
  SIZE_SEARCH_IN_IGNORE=15
  
  #Begins the plugin1's execution to warn that there are repeated sequences,  and disables all but one"
-def execute(seqs)
-   seqs.each do |s|
-     exec_seq(s)
-   end
- end
+ def exec_seq(seq,blast_query)
 
-
- def exec_seq(seq)
     $LOG.debug "[#{self.class.to_s}, seq: #{seq.seq_name}]: searching sequence repeated at input file" 
 
     fasta_input=@params.get_param('truncated_input_file')

data/lib/seqtrimnext/plugins/plugin_indeterminations.rb

@@ -140,15 +140,8 @@ class PluginIndeterminations < Plugin
  end
  
   
-   #Begins the pluginKey's execution to warn where is a key in the sequence "seq"    
-  def execute(seqs)
-   seqs.each do |s|
-         exec_seq(s)
-     end
-   end
-
+ def exec_seq(seq,blast_query)
 
-   def exec_seq(seq)
      $LOG.debug "[#{self.class.to_s}, seq: #{seq.seq_name}]: removing indeterminations N+" 
      
      actions=[]

data/lib/seqtrimnext/plugins/plugin_key.rb

@@ -11,16 +11,8 @@ class PluginKey < Plugin
   
   
    #Begins the pluginKey's execution to warn where is a key in the sequence "seq"    
-  def execute(seqs)
-     @group_by_key=(@params.get_param('use_independent_folder_for_each_key')=='true')
-     
-     seqs.each do |s|
-         exec_seq(s)
-     end
-   end
-
+   def exec_seq(seq,blast_query)
 
-   def exec_seq(seq)
      $LOG.debug "[#{self.class.to_s}, seq: #{seq.seq_name}]: marking key into the sequence" 
      # blast_table_results.inspect        
      

data/lib/seqtrimnext/plugins/plugin_linker.rb

@@ -70,15 +70,6 @@ class PluginLinker < Plugin
   		return res
   end
  
-  # Begins the plugin1's execution to warn that there is linker  into the sequence
-  def execute(seqs)
-    blasts= do_blasts(seqs)
-
-    seqs.each_with_index do |s,i|
-      exec_seq(s,blasts.querys[i])
-    end
-  end
-
   def do_blasts(seqs)
      # find MIDS  with less results than max_target_seqs value 
      blast = BatchBlast.new("-db #{@params.get_param('linkers_db')}",'blastn'," -task blastn-short  -evalue #{@params.get_param('blast_evalue_linkers')} -perc_identity #{@params.get_param('blast_percent_linkers')}")  #get linkers          

data/lib/seqtrimnext/plugins/plugin_low_complexity.rb

@@ -12,19 +12,10 @@ require "plugin"
 MIN_DUST_SIZE = 30
 
 class PluginLowComplexity < Plugin
-
-
-
-  def execute(seqs)
-    dust= do_dust(seqs)
-    
-    seqs.each_with_index do |s,i|
-      exec_seq(s,dust[i])
-    end
-  end
   
-  def do_dust(seqs)
-     # find MIDS  with less results than max_target_seqs value 
+  # do the dust masker instead of blast
+  def do_blasts(seqs)
+
      dust_masker=DustMasker.new()
 
      fastas=[]
@@ -44,7 +35,9 @@ class PluginLowComplexity < Plugin
   end
   
   
-  def exec_seq(seq,dust_query)
+  def exec_seq(seq,blast_query)
+    dust_query=blast_query
+    
     if dust_query.query_id != seq.seq_name
       raise "Blast and seq names does not match, blast:#{blast_query.query_id} sn:#{seq.seq_name}"
     end
@@ -65,14 +58,6 @@ class PluginLowComplexity < Plugin
           if (dust_size)>=MIN_DUST_SIZE
           
             # check if low complexity is inside a lowqual region
-            # in_low_qual=false
-            # low_quals.each do |lq|
-            #   if lq.contains_action?(start,stop,0)
-            #     in_low_qual=true
-            #     break
-            #   end
-            # end
-            
             if !seq.range_inside_action_type?(start,stop,ActionLowQuality)
               
               total_dust+=dust_size    

data/lib/seqtrimnext/plugins/plugin_low_high_size.rb

@@ -13,15 +13,9 @@ class PluginLowHighSize < Plugin
   
   
  # Begins the plugin_low_high_size's execution with the sequence "seq"
- 
- def execute(seqs)
-   seqs.each do |s|
-       exec_seq(s)
-    end
-  end
-  
-  
-  def exec_seq(seq)   
+
+ def exec_seq(seq,blast_query)
+
     $LOG.debug "[#{self.class.to_s}, seq: #{seq.seq_name}]: checking low or high size of the sequence"    
     
     min_size = @params.get_param('min_sequence_size_raw').to_i #min_size is: mean - 2dev
@@ -46,10 +40,6 @@ class PluginLowHighSize < Plugin
     
     
   end
-  
-  ######################################################################
-  #---------------------------------------------------------------------
-  
  
 
   ######################################################################