seqtrimnext 2.0.29

data/lib/seqtrimnext/plugins/plugin_find_poly_at.rb

@@ -0,0 +1,393 @@
+########################################################
+# Author: Almudena Bocinos Rioboo
+#
+# Defines the main methods that are necessary to execute PluginFindPolyATs
+
+#
+# Inherit: Plugin
+########################################################
+
+require "plugin"
+require "global_match"
+
+def overlap(polys,mi_start,mi_end)
+
+  # overlap = polys.find{|e| ( mi_start < e['end'])}
+  overlap = polys.find{|e| ( overlapX?(mi_start,mi_end, e['begin'],e['end']) )}
+  # puts " Overlap #{mi_start} #{mi_end} => #{overlap}"
+
+  return overlap
+end
+
+# MAX_RUBBISH = 3
+MAX_POLY_T_FROM_LEFT = 4
+MIN_TN_COUNT=15
+MAX_POLY_A_FROM_RIGHT = 10
+MIN_MIDDLE_POLY_A_SIZE = 35
+MIN_MIDDLE_POLY_T_SIZE = 35
+MAX_DUST_DISTANCE_FROM_POLYT=30
+
+class PluginFindPolyAt < Plugin
+
+  # Uses the param poly_at_length to look for at least that number of contiguous A's
+  def find_polys(ta,seq)
+    #minn = poly_at_length
+    # puts "="*20 + seq.seq_name + "="*20
+    
+    minn = 4
+    m2 = (minn/2)
+    m4 = (minn/4)
+    r = [-1,0,0]
+    re2 = /(([#{ta}]{#{m2},})(.{0,2})([#{ta}]{#{m2},}))/i
+    # re2 = /(([#{ta}]{#{m2},})(.{0,3})([#{ta}]{#{m2},}))/i
+
+    # if ta =~/A/
+    #   type='ActionPolyA'
+    # else
+    #   type='ActionPolyT'
+    #   poly_base = 'T'
+    # end
+
+    matches = re2.global_match(seq.seq_fasta,3)
+
+    # HASH
+    polys = []
+
+    # crear una region poly nuevo
+    poly = {}
+    #i=0
+
+    matches.each do |pattern2|
+
+      #puts pattern2.match[0]
+      m_start = pattern2.match.begin(0)+pattern2.offset
+      m_end = pattern2.match.end(0)+pattern2.offset-1
+
+
+      # does one exist in polys with overlap?
+      # yes => group it, updated end
+      # no => one new
+
+      if (e=overlap(polys,m_start,m_end))
+        # puts "OVERLAPS #{e}"
+        # found=seq.seq_fasta.slice(e['begin'],m_end-e['begin']+1)
+        # if base_percent(poly,ta)>= 60
+          e['end'] = m_end
+          e['found'] = seq.seq_fasta.slice(e['begin'],e['end']-e['begin']+1)
+        # else
+        #   puts "Ignored because lowers the base percent of poly"
+        # end
+        
+
+      else
+        poly={}
+        poly['begin'] = m_start
+        poly['end'] = m_end #  the next pos to pattern's end
+        poly['found'] = seq.seq_fasta.slice(poly['begin'],poly['end']-poly['begin']+1)
+        polys.push poly
+        
+        # puts " NEW POLY#{ta}: #{poly}"
+        
+      end
+
+
+
+
+    end
+    
+    # polys.each  do |p|
+    #   puts "P#{ta}: #{p}, bp: #{base_percent(p['found'],ta)}"
+    # end
+    
+    return polys
+    
+  end
+
+  
+  def find_polyA(seq)
+    
+    actions=[]
+    polys=find_polys('AN',seq)
+    poly_base = 'AN'
+    type='ActionPolyA'
+    
+    poly_size=0
+    
+    # for each poly found cut it, from right to left (reverse order)
+    polys.reverse_each do |poly|
+      
+      poly_size=poly['end'] - poly['begin'] +1
+              
+      # if polya is near right and is big enought and has a base percent
+      
+      
+      
+      # check if poly lenth and percent are above limits
+      if (poly['end']>=seq.seq_fasta.length-MAX_POLY_A_FROM_RIGHT) && (poly_size>= @params.get_param('poly_a_length').to_i) && (base_percent(poly,poly_base)>= @params.get_param('poly_a_percent').to_i)
+
+        a = seq.new_action(poly['begin'],poly['end'],type)
+        a.right_action=true    #mark as rigth action to get the left insert
+        
+        actions.push a
+        
+        add_stats('poly_a_size',poly_size)
+        
+        # if poly a is not near right but is bigger, then cut
+      elsif (poly['end']<<seq.seq_fasta.length-MAX_POLY_A_FROM_RIGHT) && (poly_size>=MIN_MIDDLE_POLY_A_SIZE) && (base_percent(poly,poly_base)>= @params.get_param('poly_a_percent').to_i)
+        
+        a = seq.new_action(poly['begin'],poly['end'],type)
+        a.right_action=true    #mark as rigth action to get the left insert
+        
+        actions.push a
+        
+        add_stats('in_middle_poly_a_size',poly_size)
+      # else
+      #         puts "REJECTED: #{poly}"
+        
+      end
+      if poly['found'].length > @params.get_param('poly_a_length').to_i
+        add_stats("poly_#{poly_base}_base_percents","#{poly['found'].length}  #{base_percent(poly,poly_base)}")
+      end
+
+    end
+
+    if !actions.empty?
+      add_stats('seqs_with_polyA',1)
+      seq.add_actions(actions)
+      actions=[]
+    end
+
+  end
+
+  def find_polyT(seq)
+    
+    actions=[]
+    poly_base = 'TN'
+    type='ActionPolyT'
+    
+    polys=find_polys('TN',seq)
+    
+    poly_size=0
+    check_for_dust=nil
+    
+    # for each poly found process it
+
+    polys.each do |poly|
+
+      poly_size=poly['end'] - poly['begin'] + 1
+      # puts "#{poly}, size: #{poly['found'].length}, bcount:#{base_percent(poly,poly_base)}"
+      # check if poly lenth and percent are above limits
+      if (poly_size>= @params.get_param('poly_t_length').to_i) && (base_percent(poly,poly_base) >= @params.get_param('poly_t_percent').to_i)
+
+        if (actions.empty?)  # first poly, check if polyT is on the left of sequence
+
+          #if is polyT and is near left, then the sequence is reversed
+          if (poly['begin']==0)
+
+            seq.seq_reversed=true
+            a = seq.new_action(poly['begin'],poly['end'],type)
+            a.left_action=true
+            actions.push a
+            
+            check_for_dust=poly
+            
+          elsif (poly['begin']<=MAX_POLY_T_FROM_LEFT && base_count(poly,'TN')>=MIN_TN_COUNT)
+            
+            seq.seq_reversed=true
+            a = seq.new_action(poly['begin'],poly['end'],type)
+            a.left_action=true
+            actions.push a
+            
+            check_for_dust=poly
+          elsif (poly['begin']>MAX_POLY_T_FROM_LEFT && base_count(poly,'TN')>=MIN_MIDDLE_POLY_T_SIZE)
+            
+            seq.seq_reversed=true
+            # seq.seq_rejected=true
+            # seq.seq_rejected_by_message='unexpected polyT'
+            check_for_dust=poly            
+            a = seq.new_action(poly['begin'],poly['end'],'ActionUnexpectedPolyT')
+            a.left_action=true
+            actions.push a
+            add_stats('unexpected_poly_t_count',poly_size)
+            
+          end
+
+        else # there are multiple polyTs
+          
+          if (poly['begin']>MAX_POLY_T_FROM_LEFT && base_count(poly,'TN')>=MIN_MIDDLE_POLY_T_SIZE)
+            
+            seq.seq_reversed=true
+            # seq.seq_rejected=true
+            # seq.seq_rejected_by_message='unexpected polyT'
+
+            check_for_dust=poly
+            
+            a = seq.new_action(poly['begin'],poly['end'],'ActionUnexpectedPolyT')
+            a.left_action=true
+            actions.push a
+            add_stats('unexpected_poly_t_count',poly_size)
+            
+          end
+          
+        end
+
+
+
+
+
+          # if (poly['begin']<=MAX_POLY_T_FROM_LEFT*2)
+          #   seq.seq_rejected=true
+          #   seq.seq_rejected_by_message='polyT found'
+          # end
+
+          # @stats[:poly_t_size]={poly_size => 1}
+          add_stats('poly_t_size',poly_size)
+          
+
+
+      end
+
+    end
+
+    if !actions.empty?
+      add_stats('seqs_with_polyT',1)
+      seq.add_actions(actions)
+      
+      actions=[]
+      if check_for_dust && !seq.seq_fasta.nil? && !seq.seq_fasta.empty?
+        dust_masker=DustMasker.new()
+        dust_poly_size=check_for_dust['end']-check_for_dust['begin']+1
+        found_dust = dust_masker.do_dust([">"+seq.seq_name,seq.seq_fasta])
+        # puts "Checking for dust: #{seq.seq_fasta}"
+        # puts found_dust.to_json
+        total_dust=0
+        last_dust_start=0
+        
+        if !found_dust.empty?
+          found_dust[0].dust.each do |dust|
+            start=dust[0]
+            stop=dust[1]
+            dust_size=dust[1]-dust[0]+1
+            total_dust+=dust_size
+
+            # dust must be big enought and be near the polyt to be a induced one
+            if (dust_size)>10 && (start<last_dust_start+MAX_DUST_DISTANCE_FROM_POLYT)
+              last_dust_start=stop
+              a = seq.new_action(start,stop,'ActionInducedLowComplexity')
+              # a.left_action=true
+              actions.push a
+            elsif dust_size>10
+              a = seq.new_action(start,stop,'ActionLowComplexity')
+              # a.left_action=true
+              actions.push a
+            end
+          end
+        end
+        
+        
+        
+        if !actions.empty?
+          add_stats('poly_t_dust',dust_poly_size)
+          seq.add_actions(actions)
+        else
+          add_stats('poly_t_no_dust',dust_poly_size)
+        end
+        
+        # reject sequences if total dust is greater than 30
+        if total_dust>30
+          # if seq.seq_fasta.length<50
+            seq.seq_rejected=true
+            seq.seq_rejected_by_message='low complexity by polyt'
+          # end
+          
+          add_stats('induced_low_complexity',total_dust)
+        end
+        
+        
+      end
+    end
+
+  end
+
+
+
+ def execute(seqs)
+   seqs.each do |s|
+       exec_seq(s)
+    end
+  end
+
+
+  def exec_seq(seq)
+    $LOG.info "[#{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)
+    find_polyA(seq)
+
+  end
+
+  ######################################################################
+  #---------------------------------------------------------------------
+
+
+  def base_percent(poly,poly_base)
+
+    # count Ts en poly['found']
+    s=poly['found']
+    ta_count = s.count(poly_base.downcase+poly_base.upcase)
+
+    res=(ta_count.to_f/s.size.to_f)*100
+    
+    # puts "poly #{s} base percent #{res}"
+
+
+    return res
+  end
+
+  def base_count(poly,poly_base)
+
+    # count bases en poly['found']
+    s=poly['found']
+    res = s.count(poly_base.downcase+poly_base.upcase)
+
+    # puts "poly #{s} base count #{res}"
+
+    return res
+  end
+
+
+  ######################################################################
+  #---------------------------------------------------------------------
+
+  #Returns an array with the errors due to parameters are missing
+  def self.check_params(params)
+    errors=[]
+
+    comment='Minimum length of a poly-A'
+		default_value = 6
+		params.check_param(errors,'poly_a_length','Integer',default_value,comment)
+
+    comment='Minimum percent of As in a sequence segment to be considered a poly-A'
+    # default_value = 80
+    default_value = 75
+		params.check_param(errors,'poly_a_percent','Integer',default_value,comment)
+
+
+    comment='Minimum length of a poly-T'
+		default_value = 15
+		params.check_param(errors,'poly_t_length','Integer',default_value,comment)
+
+    comment='Minimum percent of Ts in a sequence segment to be considered a poly-T'
+    # default_value = 80
+    default_value = 75
+		params.check_param(errors,'poly_t_percent','Integer',default_value,comment)
+
+    return errors
+  end
+
+
+
+
+  private :overlap
+
+end

data/lib/seqtrimnext/plugins/plugin_ignore_repeated.rb

@@ -0,0 +1,101 @@
+require "plugin"
+
+require "make_blast_db"
+########################################################
+# Author: Almudena Bocinos Rioboo                      
+# 
+# Defines the main methods that are necessary to execute PluginIgnoreRepeated                                                     
+# Inherit: Plugin
+########################################################
+
+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)
+    $LOG.info "[#{self.class.to_s}, seq: #{seq.seq_name}]: searching sequence repeated at input file" 
+
+    fasta_input=@params.get_param('truncated_input_file')
+    
+    blast = BatchBlast.new("-db #{fasta_input}" ,'blastn'," -task blastn-short -searchsp #{SIZE_SEARCH_IN_IGNORE} -evalue #{@params.get_param('blast_evalue_ignore_repeated')} -perc_identity #{@params.get_param('blast_percent_ignore_repeated')}")  #get contaminants
+    
+    p_start = @params.get_param('piro_repeated_start').to_i
+    p_length = @params.get_param('piro_repeated_length').to_i
+    
+    
+    blast_table_results = blast.do_blast(seq.seq_fasta[p_start,p_length])             #rise seq to contaminants  executing over blast
+    
+    #blast_table_results = BlastTableResult.new(res)
+    
+ 
+     type = "ActionIgnoreRepeated"        
+     
+     # @stats[:rejected_seqs]={}    
+       
+     actions=[]     
+     blast_table_results.querys.each do |query|
+                                               
+           # puts "BLAST IGUALES:"
+           # puts res.join("\n")       
+       if query.size>1   
+         names = query.hits.collect{ |h| 
+              if h.align_len > (p_length-2)
+                h.subject_id
+              end
+         }
+             
+         names.compact!   
+          
+          # puts "IGUALES:" + names.size.to_s 
+          #            puts names.join(',')               
+          
+          if !names.empty?
+             names.sort!
+				     
+             if (names[0] != seq.seq_name)   # Add action when the sequence  is repeated 
+				     #  if true 
+				        a = seq.new_action(0,0,type)
+				        a.message = seq.seq_name  + ' equal to ' + names[0]    
+				        actions.push a
+				        seq.seq_rejected=true   
+				        seq.seq_rejected_by_message='repeated'
+				        seq.seq_repeated=true       
+				        
+                # @stats[:rejected_seqs]={'rejected_seqs_by_repe' => 1}   
+                add_stats('rejected_seqs','rejected_seqs_by_repe') 
+                 # puts "#{names[0]} != #{seq.seq_name} >>>>>>"       
+				     end                                                               
+         end
+         
+       end       
+       
+     end 
+     
+     seq.add_actions(actions)
+     
+  end
+
+
+
+  #Returns an array with the errors due to parameters are missing 
+  def self.check_params(params)
+    errors=[]
+                  
+     # self.check_param(errors,params,'fasta_file_input','String')
+     self.check_param(errors,params,'blast_evalue_ignore_repeated','Float') 
+     self.check_param(errors,params,'blast_percent_ignore_repeated','Integer')
+     self.check_param(errors,params,'piro_repeated_start','Integer')
+     self.check_param(errors,params,'piro_repeated_length','Integer')
+    return errors
+  end
+  
+  
+end

data/lib/seqtrimnext/plugins/plugin_indeterminations.rb

@@ -0,0 +1,199 @@
+########################################################
+# Author: Almudena Bocinos Rioboo                      
+# 
+# Defines the main methods that are necessary to execute PluginIndeterminations                                                     
+# Inherit: Plugin
+########################################################
+require "plugin"
+require "global_match"
+
+
+class PluginIndeterminations < Plugin   
+  
+
+	def overlap(polys,mi_start,mi_end)
+		
+		# overlap = polys.find{|e| ( mi_start < e['end'])}
+		overlap = polys.find{|e| ( overlapX?(mi_start,mi_end, e['begin'],e['end']) )}
+		# puts " Overlap #{mi_start} #{mi_end} => #{overlap}"
+		
+		return overlap
+	end
+
+	MAX_RUBBISH = 3
+ 
+ # Begins the pluginFindPolyAt's execution whit the sequence "seq"
+ 
+ # Uses the param poly_at_length to look for at least that number of contiguous A's
+  def find_polys(ta,seq,actions)
+
+    minn = 4
+    m2 = 1#(minn/2) 
+    m4 = (minn/4)
+    r = [-1,0,0]
+    re2 = /((#{ta}{#{m2},})(.{0,3})(#{ta}{#{1},}))/i
+    
+    
+    type='ActionIndetermination'
+    poly_base = 'N'
+    
+    matches = re2.global_match(seq.seq_fasta,3)
+
+		matches2 = /[^N]N$/.match(seq.seq_fasta)
+		
+		
+    # HASH
+    polys = []
+
+    # crear una region poly nuevo
+    poly = {}
+    #i=0
+
+    matches.each do |pattern2|
+
+      #puts pattern2.match[0]
+        m_start = pattern2.match.begin(0)+pattern2.offset
+        m_end = pattern2.match.end(0)+pattern2.offset-1   
+        
+			 #puts "MATCH: #{m_start} #{m_end}"
+
+       # does one exist in polys with overlap?
+
+       # yes => group it, updated end
+
+       # no => one new
+
+       if (e=overlap(polys,m_start,m_end))
+         
+         e['end'] = m_end
+         e['found'] = seq.seq_fasta.slice(e['begin'],e['end']-e['begin']+1)
+         
+       else
+          poly={}
+          poly['begin'] = m_start
+          poly['end'] = m_end #  the next pos to pattern's end
+          poly['found'] = seq.seq_fasta.slice(poly['begin'],poly['end']-poly['begin']+1)
+          polys.push poly
+       end
+       
+    end  
+    
+    
+    poly_size=0 
+
+    polys.each do |poly|
+      #puts "NEW POLY: #{poly.to_json}"
+    		
+    		if poly_near_end(poly['end'],seq.seq_fasta) # near right side
+    		  #puts "near end"
+        a = seq.new_action(poly['begin'],poly['end'],type)
+        a.right_action=true
+        actions.push a
+        
+        poly_size=poly['end']-poly['begin']+1
+        add_stats('size',poly_size)
+      else
+      		#puts "far of end"
+	      if check_poly_length(poly['begin'],poly['end']) and (check_poly_percent(poly,poly_base))
+	      		#puts "ok"
+			    a = seq.new_action(poly['begin'],poly['end'],type)
+		      a.right_action=true
+		      actions.push a
+		  
+		      seq.seq_rejected=true 
+          seq.seq_rejected_by_message='Indeterminations in middle of sequence'
+		  
+		      poly_size=poly['end']-poly['begin']+1
+		      add_stats('size',poly_size)
+	      end
+      
+      
+      end
+    end 
+    
+    
+  end
+  
+    
+ def check_poly_length(poly_start,poly_end)
+   #puts "poly_length: #{1+(poly_end-poly_start)} nt"
+   return (1+(poly_end-poly_start)) >= @params.get_param('poly_n_length').to_i
+ end
+
+ def check_poly_percent(poly,poly_base)
+   
+   # count Ts en poly['found']
+   s=poly['found']
+   ta_count = s.count(poly_base.downcase+poly_base.upcase)
+   #puts "poly_percent: #{(ta_count.to_f/s.size.to_f)*100}%"
+   res=((ta_count.to_f/s.size.to_f)*100 >= @params.get_param('poly_n_percent').to_i)
+   
+   return res
+ end
+ 
+ def poly_near_end(pos,seq_fasta)
+ 
+ 	max_to_end = @params.get_param('poly_n_max_to_end').to_i
+ 	
+ 	res = (pos>=(seq_fasta.length-max_to_end))
+ 	
+ 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)
+     $LOG.info "[#{self.class.to_s}, seq: #{seq.seq_name}]: removing indeterminations N+" 
+     
+     actions=[]
+     
+     # find simple indeterminations at end of sequence
+			match=seq.seq_fasta.match(/[nN]+$/)
+     
+     if !match.nil?
+			 found=match[0].length
+
+       
+       a = seq.new_action(seq.seq_fasta.length-found,seq.seq_fasta.length,'ActionIndetermination')
+       a.right_action=true
+       actions.push a       
+
+       #Add actions  
+       seq.add_actions(actions)
+       actions=[]
+       add_stats('indetermination_size',found)
+	
+     end
+     
+     find_polys('[N]',seq,actions)
+     seq.add_actions(actions)
+     
+   end
+ 
+  #Returns an array with the errors due to parameters are missing 
+  def self.check_params(params)
+    errors=[]
+    
+ 		comment='Minimum number of Ns within the sequence to be rejected by having an internal segment of indeterminations. Indeterminations at the end of the sequence will be removed regardless of their size and without rejecting the sequence'
+		default_value = 15
+		params.check_param(errors,'poly_n_length','Integer',default_value,comment)
+    
+ 		comment='Minimum percent of Ns in a segment to be considered a valid indetermination'
+		default_value = 80
+		params.check_param(errors,'poly_n_percent','Integer',default_value,comment)
+
+ 		comment='Maximum distance to the end of the sequence to be considered an internal segment'
+		default_value = 15
+		params.check_param(errors,'poly_n_max_to_end','Integer',default_value,comment)
+    
+    return errors
+  end
+  
+  
+end