seqtrimnext 2.0.29

data/lib/seqtrimnext/classes/params.rb

@@ -0,0 +1,387 @@
+#########################################
+# Author:: Almudena Bocinos Rioboo
+# This class provided the methods to read the parameter's file and to create the structure where will be storaged the param's name and the param's numeric-value
+#########################################
+require 'scbi_fasta'
+
+class Params
+
+  #Creates the structure and start the reading of parameter's file
+  def initialize(path)
+    @params = {}
+    @comments = {}
+    # @param_order={}
+    @mids = {}
+    @linkers = {}
+    @clusters = {}
+
+    @plugin_comments = {}
+
+    read_file(path)
+  end
+
+  # Reads param's file
+  def read_file(path_file)
+
+    if path_file && File.exists?(path_file)
+      comments= []
+      File.open(path_file).each_line do |line|
+        line.chomp! # delete end of line
+
+        if !line.empty?
+          if !(line =~ /^\s*#/)   # if line is not a comment
+            # extract the parameter's name in params[0] and the parameter's value in params[1]
+            params = line.split(/\s*=\s*/)
+
+            # store in the hash the pair key/value, in our case will be name/numeric-value ,
+            # that are save in params[0] and params[1],  respectively
+            if (!params[0].nil?) && (!params[1].nil?)
+              set_param(params[0].strip,params[1].strip,comments)
+              comments=[]
+            end
+
+            #$LOG.debug "read: #{params[1]}"
+          else
+            comments << line.gsub(/^\s*#/,'')
+          end # end if comentario
+        end #end if line
+      end #end each
+      if @params.empty?
+        puts "INVALID PARAMETER FILE: #{path_file}. No parameters defined"
+        exit
+      end
+
+    end
+  end# end def
+
+  # Load mid's file
+  def load_mids(path_file)
+    if File.exists?(path_file)
+      ff = FastaFile.new(path_file)
+      ff.each {|n,f|
+        # @mid_sizes[n]=f.size
+        @mids[n]=f
+      }
+
+      ff.close
+    end
+  end
+
+  # Load mid's file
+  def load_linkers(path_file)
+    if File.exists?(path_file)
+      ff = FastaFile.new(path_file)
+      ff.each {|n,f|
+        @linkers[n]=f
+      }
+      ff.close
+    end
+  end
+
+  def load_repeated_seqs(file_path)
+    @clusters={}
+
+    if File.exists?(file_path)
+      # File.open(ARGV[0]).each_line do |line|
+      $LOG.debug("Repeated file path:"+file_path)
+      File.open(file_path).each_line do |line|
+        #puts line,line[0]
+        # en ruby19 line[0] da el caracter, no el chr
+        #if (line[0]!=62) && (line[0]!=48)
+        if (line[0]!='>'[0]) && (line[0]!='0'[0])
+          #puts line
+          #puts line,line[0]
+          if line =~ />([^\.]+)\.\.\.\s/
+            #puts 'ok'
+            @clusters[$1]=1
+          end
+        end
+      end
+      $LOG.info("Repeated sequence count: #{@clusters.count}")
+    else
+      $LOG.error("Clustering file's doesn't exists: #{@clusters.count}")
+    end
+
+
+  end
+
+  def repeated_seq?(name)
+    return !@clusters[name].nil?
+  end
+
+  # Reads param's file
+  def save_file(path_file)
+
+    f=File.open(path_file,'w')
+    @plugin_comments.keys.sort.reverse.each do |plugin_name|
+      f.puts "#"*50
+      f.puts "# " + plugin_name
+      f.puts "#"*50
+      f.puts ''
+
+      @plugin_comments[plugin_name].keys.each do |param|
+        comment=get_comment(plugin_name,param)
+        if !comment.nil? && !comment.empty? && comment!=''
+          f.puts comment.map{|c| '# '+c if c!=''}
+        end
+        f.puts ''
+        f.puts "#{param} = #{@params[param]}"
+        f.puts ''
+      end
+    end
+    f.close
+
+  end# end def
+
+  #  Prints the pair name/numeric-value for every parameter
+  def print_parameters()
+    @params.each do |clave, valor|
+      #$LOG.debug  "The Parameter #{clave} have the value " +valor.to_s
+      puts "#{clave} = #{valor} "
+    end
+  end
+
+  # Return the parameter's list in an array
+  def get_param(param)
+    #$LOG.debug "Get Param:  #{@params[param]}"
+    return @params[param]
+  end
+
+  # Return the mid's size of param
+  def get_mid(param)
+    return @mids[param]
+  end
+
+  # Return the linker of param
+  def get_linker(linker)
+    return @linkers[linker]
+  end
+
+  def get_plugin
+    plugin='General'
+    # puts caller(2)[1]
+    at = caller(2)[1]
+    if /^(.+?):(\d+)(?::in `(.*)')?/ =~ at
+      file = Regexp.last_match[1]
+      line = Regexp.last_match[2].to_i
+      method = Regexp.last_match[3]
+      plugin=File.basename(file,File.extname(file))
+      
+      # puts "CALLER: #{plugin}"
+      # puts [file, line, method]
+
+    end
+    
+  end
+  
+  def set_param(param,value,comment=nil)
+                         plugin=get_plugin
+
+                         @params[param] = value
+
+                         if get_comment(plugin,param).nil?
+                           set_comment(plugin,param,comment)
+                         end
+
+
+                       end
+  
+  # def set_order(plugin,param)
+  #      
+  #      if @param_order[plugin].nil?
+  #        @param_order[plugin]=[]
+  #    end
+  #    
+  #    if !@param_order[plugin].index(param)
+  #      @param_order[plugin].push param
+  #    end
+  # end
+    
+  
+  def get_comment(plugin,param)
+                         res = nil
+                         if @plugin_comments[plugin]
+                           res =@plugin_comments[plugin][param]
+                         end
+                         return res
+                       end
+  
+  
+  def set_comment(plugin,param,comment)
+                         if !comment.is_a?(Array) && !comment.nil?
+                           comment=comment.split("\n").compact.map{|l| l.strip}
+                         end
+
+                         if @plugin_comments[plugin].nil?
+                           @plugin_comments[plugin]={}
+                         end
+
+                         old_comment=''
+                         # remove from other plugins
+                         @plugin_comments.each do |plugin_name,comments|
+                           if comments.keys.include?(param) && plugin_name!=plugin
+                             old_comment=comments[param]
+                             comments.delete(param)
+                           end
+                         end
+
+                         if comment.nil?
+                           comment=old_comment
+                         end
+
+                         # @comments[param]=(comment || [''])
+                         @plugin_comments[plugin][param]=(comment || [''])
+                         # puts @plugin_comments.keys.to_json
+
+                         # remove empty comments
+
+                         @plugin_comments.reverse_each do |plugin_name,comments|
+                           if comments.empty?
+                             @plugin_comments.delete(plugin_name)
+                           end
+                         end
+
+                       end
+       
+  
+  def set_mid(param,value)
+                         @mids[param] = value
+                       end
+  #attr_accessor :h  # to accede to the atribute 'h' from out of this class
+  
+  # Returns true if exists the parameter and nil if don't
+  def exists?(param_name)
+                         return !@params[param_name].nil?
+                       end
+  
+  def check_plugin_list_param(errors,param_name)
+                         # get plugin list
+                         pl_list=get_param(param_name)
+
+                         # puts pl_list,param_name
+                         list=pl_list.split(',')
+
+                         list.map!{|e| e.strip}
+
+                         # puts "Lista:",list.join(',')
+
+
+                         # always the pluginExtractInserts at the end
+                         list.delete('PluginExtractInserts')
+                         list << 'PluginExtractInserts'
+
+                         set_param(param_name,list.join(','))
+                         # if !list.include?('PluginExtractInserts')
+                         #   raise "PluginExtractInserts do not exists"
+                         #
+                         # end
+
+
+
+                       end
+
+  # def split_databases(db_param_name)
+  def check_db_param(errors,db_param_name)
+                         # expand database paths
+                         dbs= get_param(db_param_name).gsub('"','').split(/\s+/)
+                         # puts "ALGO"*20
+                         puts dbs.join(',')
+                         #
+                         # TODO - chequear aqui que la db no esta vacia y que esta formateada.
+                         dbs.reverse_each {|db|
+                           if !File.exists?(db)
+                             path=File.join($FORMATTED_DB_PATH,db)
+                           else
+                             path=db
+                           end
+
+                           if Dir.glob(path+'*.n*').entries.empty?
+                             puts "DB file #{path} not formatted"
+
+                             if File.writable_real?(path)
+                               cmd = "makeblastdb -in #{path} -parse_seqids -dbtype nucl"
+                               system(cmd)
+                             else
+                               raise "Can't format database. We don't have write permissions in: #{path}"
+                             end
+                           end
+
+                           if !File.exists?(path)
+                             raise "DB File #{path} does not exists"
+                             # exit
+                           end
+                         }
+                         db_paths = '"'+dbs.join(' ')+'"'
+
+                         set_param(db_param_name,db_paths)
+                         # puts "DATABASES"+db_paths
+                       end
+  
+  
+  def self.generate_sample_params
+
+                         filename = 'sample_params.txt'
+                         x=1
+                         while File.exists?(filename)
+                           filename = "sample_params#{x}.txt"
+                           x+=1
+                         end
+
+                         f=File.open(filename,'w')
+                         f.puts "SAMPLE_PARAMS"
+                         f.close
+
+                         puts "Sample params file generated: #{filename}"
+
+                       end
+  
+  def check_param(errors,param,param_class,default_value=nil, comment=nil)
+                  
+                         if !exists?(param)
+                           if default_value.nil? #|| (default_value.is_a?(String) && default_value.empty?)
+                             errors.push "The param #{param} is required and no default value is available"
+                           else
+                             set_param(param,default_value,comment)
+                           end
+                         end
+
+                           s = get_param(param)
+
+
+                           set_comment(get_plugin,param,comment)
+
+                           # check_class=Object.const_get(param_class)
+                           begin
+
+                             case param_class
+                             when 'Integer'
+                               r = Integer(s)
+                             when 'Float'
+                               r = Float(s)
+                             when 'String'
+                               r = String(s)
+                             when 'DB'
+                               # it is a string
+                               r = String(s)
+                               # and must be a valid db
+                               
+                               r = check_db_param(errors,param)
+
+                             when 'PluginList'
+                               r=String(s)
+                               r= check_plugin_list_param(errors,param)
+                             end
+
+                           rescue Exception => e
+                             message="Current value is ##{s}#. "
+                             if param_class=='DB'
+                               message += e.message
+                             end
+
+                             errors.push "Param #{param} is not a valid #{param_class}. #{message}"
+                           end
+                         # end
+
+                       end
+
+end

data/lib/seqtrimnext/classes/piro.rb

@@ -0,0 +1,78 @@
+# require '../utils/fasta_qual_reader' #descomentar en test_extracts
+require 'fasta_qual_reader'   #descomentar en seqtrimii
+
+
+
+require 'make_blast_db'
+require 'scbi_blast'
+
+
+
+
+######################################
+# Author:: Almudena Bocinos Rioboo
+# Extract stats like mean of sequence's length 
+# Inherit:: FastaReader
+######################################
+
+class Piro < FastaQualReader
+  #attr_accessor :na
+  def initialize(path_fasta,path_qual)
+    @path_fasta=path_fasta
+    super(path_fasta,path_qual)
+    MakeBlastDb.execute('../sequences/gemini.fasta')
+    
+    
+  end
+  
+  def on_process_sequence(name_seq,fasta_seq,qual_seq)
+    puts "in piro, in on process sequence, #{name_seq}"
+    
+   
+    blast = BatchBlast.new('-db '+ @path_fasta ,'blastn',' -task blastn -evalue 1e-10 -perc_identity 95')  #get contaminants
+    #blast = BatchBlast.new('DB/vectors.fasta','blastn',' -task blastn ')  #get vectors
+
+     $LOG.debug "-------OK----"
+
+    # puts seq.seq_fasta
+     res = blast.do_blast(fasta_seq)             #rise seq to contaminants  executing over blast
+    # 
+    #     blast_table_results = BlastTableResult.new(res,nil)
+    
+    # vectors=[]
+    #     blast_table_results.querys.each do |query|     # first round to save contaminants without overlap
+    #       merge_hits(query.hits,vectors)
+    #     end
+    # 
+    #     begin 
+    #       vectors2=vectors                            # second round to save contaminants without overlap
+    #       vectors = []
+    #       merge_hits(vectors2,vectors)
+    #     end until (vectors2.count == vectors.count) 
+    # 
+    # 
+    #     vectors.each do |c|                           # adds the correspondent action to the sequence
+    #       #if @seq_specie!=seq_specie-contaminant
+    # 
+    #       if (@params.get_param('genus')!=c.subject_id.split('_')[1])
+    #          # puts "DIFFERENT SPECIE #{specie} ,#{hit.subject_id.split('_')[1].to_s}"
+    #          a = seq.add_action(c.q_beg,c.q_end,type)
+    #          a.message = c.subject_id
+    #       end
+    #     end
+    
+    
+  end
+  
+  def on_end_process()
+    
+
+
+    
+ 
+ 
+  end
+  
+
+  
+end

data/lib/seqtrimnext/classes/plugin_manager.rb

@@ -0,0 +1,153 @@
+#########################################
+# Author:: Almudena Bocinos Rioboo
+# This class provided the methods to manage the execution of the plugins
+ #########################################
+
+require 'json'
+
+require 'sequence_with_action'
+require 'sequence_group'
+
+class PluginManager   
+  attr_accessor :plugin_names
+  
+  #Storages the necessary plugins specified in 'plugin_list' and start the loading of plugins
+  def initialize(plugin_list,params)
+    @plugin_names = plugin_list.strip.split(',').map{|p| p.strip}.reject{|p| ['',nil].include?(p)}
+    @params = params
+    
+    # puts plugin_list
+    load_plugins_from_files     
+    
+  end
+  
+  # Receives the plugin's list , and create an instance from its respective class (it's that have the same name)
+  def execute_plugins(running_seqs)
+    # $LOG.info " Begin process: Execute plugins "
+    
+    if !@plugin_names.empty?
+      
+      # keeps a list of rejected sequences
+      
+
+      rejected_seqs = []
+
+      @plugin_names.each do |plugin_name|
+        
+        
+        # remove rejected or empty seqs from execution list
+        running_seqs.reverse_each do |seq|
+          if seq.seq_rejected || seq.seq_fasta.empty?
+            # remove from running
+            running_seqs.delete(seq)
+            # save in rejecteds
+            rejected_seqs.push seq
+          end
+        end
+        
+        if running_seqs.empty?
+          break
+        end
+        
+        # Creates an instance of the respective plugin stored in "plugin_name",and asociate it to the sequence 'seq'
+        plugin_class = Object.const_get(plugin_name)
+        # puts "ANTES *************" + seq.to_text_seq_fasta
+        plugin_execution=plugin_class.new(running_seqs,@params)
+        #puts plugin_name+':'+ plugin_execution.stats.to_json
+        running_seqs.stats[plugin_name] = plugin_execution.stats
+
+        
+        # puts running_seqs.stats.to_json
+        plugin_execution=nil
+
+
+      end #end  each
+      
+      running_seqs.add(rejected_seqs)
+
+      
+    else
+      
+      raise "Plugin list not found"
+    end #end  if lista-param
+  end
+  
+  # Checks if the parameters are right for all plugins's execution. Finally return true if all is right or false if isn't 
+  def check_plugins_params(params)
+    res = true
+    
+    if !@plugin_names.empty?
+      #$LOG.debug " Check params values #{plugin_list} "
+
+      @plugin_names.each do |plugin_name|
+        
+        #Call to the respective plugin storaged in 'plugin_name'
+        plugin_class = Object.const_get(plugin_name)
+        # DONE - chequear si es un plugin de verdad u otra clase
+        # puts plugin_class,plugin_class.ancestors.map {|e| puts e,e.class}
+        
+        if plugin_class.ancestors.include?(Plugin)
+          errors=plugin_class.check_params(params)          
+        else
+          errors= [plugin_name + ' is not a valid plugin']
+        end
+
+        if !errors.empty?
+          $LOG.error plugin_name+ ' found following errors:'
+          errors.each do |error|
+            $LOG.error '   -' + error
+            res = false
+          end #end each
+        end #end if
+
+      end #end  each
+    else
+      $LOG.error "No plugin list provided"
+      res = false
+    end #end  if plugin-list
+    
+    return res
+  end
+  
+  
+  # Iterates by the files from the folder 'plugins', and load it
+  def load_plugins_from_files
+           
+    # DONE - CARGAR los plugins que hay en @plugin_names en vez de todos 
+    
+    # the plugin_name changes to file using plugin_name.decamelize    
+    @plugin_names.each do |plugin_name|
+      plugin_file = plugin_name.decamelize
+      require plugin_file
+    end
+    
+  end # end  def
+    
+  
+  # Iterates by the files from the folder 'plugins', and load it
+  def load_plugins_from_files_old
+           
+    # DONE - CARGAR los plugins que hay en @plugin_names en vez de todos
+    
+    
+    
+    ignore = ['.','..','plugin.rb']
+    #carpeta=Dir.open("progs/ruby/seqtrimii/plugins")
+
+    plugins_path = File.expand_path(File.join(File.dirname(__FILE__), "../plugins"))
+    if !File.exists?(plugins_path)
+    	raise "Plugin folder does not exists"
+    end
+    
+    # carpeta=Dir.open(plugins_path)
+    entries = Dir.glob(File.join(plugins_path,'*.rb'))
+    # carpeta.
+    entries.each do |plugin|
+      if !ignore.include?(plugin)
+          require plugin
+      end # end  if
+    end # end  each
+  end # end  def
+  
+  
+end