scbi_blast 0.0.30

data/lib/scbi_blast/blast_table_result.rb

@@ -0,0 +1,190 @@
+require "blast_query.rb"
+require "blast_hit.rb"
+
+
+
+######################################
+# Author:: Almudena Bocinos Rioboo
+# Extracts results from blast table's file and uses it to create instances of "BlastQuery" and "BlastHit" 
+
+######################################
+
+class BlastTableResult
+                      
+  def initialize(input)
+    
+    @querys = []
+    
+    
+    if input.is_a?(Array)
+      lines=input
+      
+    else
+      
+      fich = File.open(input,'r')
+      lines = fich.readlines
+      fich.close
+      
+    end
+    
+    # puts "lines length #{lines.length}" 
+    query_name=''
+    
+    lines.each do |line|
+      
+      line.chomp! #delete end of line
+   
+        if line =~ /^\s*#/
+          if line =~ /^#\sQuery:\s+(.+)$/
+            query_name = $1
+          elsif line =~ /^#\s0\shits\sfound$/
+            @querys.push BlastQuery.new(query_name)
+          end
+          # 0 hits found
+          
+          
+        else
+           params = line.split(/\t+/)
+           
+           # creates the hit
+           #hit = BlastHit.new( params[1], params[2], params[3], params[4], params[5], params[6], params[7], params[8], params[9], params[10], params[11])
+           
+           # puts "Extracted #{params[0]} #{params[1]} #{params[2]} #{params[3]} #{params[4]} #{params[5]} #{params[6]} #{params[7]} #{params[8]} #{params[9]} #{params[10]} #{params[11]}"
+ #         Options 6, 7, and 10 can be additionally configured to produce
+#   a custom format specified by space delimited format specifiers.
+#   The supported format specifiers are:
+#            qseqid means Query Seq-id
+#               qgi means Query GI
+#              qacc means Query accesion
+#            sseqid means Subject Seq-id
+#         sallseqid means All subject Seq-id(s), separated by a ';'
+#               sgi means Subject GI
+#            sallgi means All subject GIs
+#              sacc means Subject accession
+#           sallacc means All subject accessions
+#            qstart means Start of alignment in query
+#              qend means End of alignment in query
+#            sstart means Start of alignment in subject
+#              send means End of alignment in subject
+#              qseq means Aligned part of query sequence
+#              sseq means Aligned part of subject sequence
+#            evalue means Expect value
+#          bitscore means Bit score
+#             score means Raw score
+#            length means Alignment length
+#                        pident means Percentage of identical matches
+#            nident means Number of identical matches
+#          mismatch means Number of mismatches
+#          positive means Number of positive-scoring matches
+#           gapopen means Number of gap openings
+#              gaps means Total number of gaps
+#              ppos means Percentage of positive-scoring matches
+#            frames means Query and subject frames separated by a '/'
+#            qframe means Query frame
+#            sframe means Subject frame
+#   When not provided, the default value is:
+#   'qseqid sseqid pident length mismatch gapopen qstart qend sstart send
+#   evalue bitscore', which is equivalent to the keyword 'std'
+
+           # if  the query doesn't exist, then create a new one,
+           # else the hit will be added to the last query  
+
+           qseqid,sacc,pident,length,mismatch,gapopen,qstart,qend,sstart,send,evalue,bitscore,score,qframe,sframe,qseq,sseq = params
+            
+   							   # creates the hit
+								   hit = BlastHit.new(qstart,qend,sstart,send)
+
+								   hit.align_len=length								   
+								   hit.ident=pident
+								   
+								   hit.gaps=gapopen
+		 				       hit.mismatches=mismatch
+							     hit.e_val=evalue
+								   hit.bit_score=bitscore
+								   
+								   hit.score = score
+								   hit.q_frame = qframe
+								   hit.s_frame = sframe
+								   
+								   hit.subject_id = sacc
+								   hit.full_subject_length=0
+								   hit.definition=sacc
+								   hit.acc=sacc
+								   hit.q_seq=qseq
+								   hit.s_seq=sseq
+
+            query=find_query(@querys,qseqid)
+            
+            if (query)   #if it is a new query, it is created and added
+              query.add_hit(hit)
+                            
+            else      # else the hit is added in last query added        
+              query = BlastQuery.new(qseqid)
+              query.add_hit(hit)
+              @querys.push query     
+            end
+           
+           
+           #Description
+
+           # read_blast_tab read tabular BLAST format created with blast_seq and written to file with write_blast - or with blastall and the -m 8 or -m 9 switch. 
+           #           Each column in the table corresponds to the following keys:
+           # 
+           #              1. Q_ID - Query ID.
+           #              2. S_ID - Subject ID.
+           #              3. IDENT - Identity (%).
+           #              4. ALIGN_LEN - Alignment length.
+           #              5. MISMATCHES - Number of mismatches.
+           #              6. GAPS - Number of gaps.
+           #              7. Q_BEG - Query begin.
+           #              8. Q_END - Query end.
+           #              9. S_BEG - Subject begin.
+           #             10. S_END - Subject end.
+           #             11. E_VAL - Expect value.
+           #             12. BIT_SCORE - Bit score. 
+           # 
+           #           Furthermore, two extra keys are added to the record:
+           # 
+           #               * STRAND - Strand.
+           #               * REC_TYPE - Record type.
+        end
+      end
+      
+      #inspect
+    
+  end
+  
+  
+  
+  def inspect    
+#    puts "Table Results:"
+#    puts(@querys.each{|q| q.inspect}).join("\n")
+ res = "Blast results:\n"
+    res+= '-'*20
+    res+= "\nQuerys: #{@querys.count}\n"
+    @querys.each{|q| res+=q.inspect+"\n"}
+    return res    
+  end
+  
+  def find_query(querys,name_q)  
+  #  newq = querys.find{|q| ( q.find{|h| (h.subject_id)})}
+    new_q=nil
+
+    if !querys.empty?
+      new_q=querys.find{|q| (q.query_id==name_q)}
+    end
+
+    return new_q
+  end
+  
+  def empty?
+    
+    return @querys.empty?
+  end  
+  
+  def size
+    @querys.size
+  end
+
+  attr_accessor :querys
+end

data/lib/scbi_blast/blast_xml_result.rb

@@ -0,0 +1,152 @@
+require "blast_query.rb"
+require "blast_hit.rb"
+
+require 'nokogiri'
+#xml=File.open('orf.1.xml').read
+#data = XmlSimple.xml_in(xml)
+#
+#
+#data['best_orf'][0]['start'][0]
+#data['best_orf'][0]['content']
+
+######################################
+# Author:: Almudena Bocinos Rioboo
+# Extracts results from blast table's file and uses it to create instances of "BlastQuery" and "BlastHit" 
+
+######################################
+
+class BlastXmlResult
+                      
+  def initialize(input)
+    
+    @querys = []
+    lines=[]
+    
+    if input.is_a?(Array)
+      lines=input
+    else
+      if File.exists?(input)
+        fich = File.open(input,'r')
+        lines = fich.readlines
+        fich.close
+      end
+      
+    end
+    
+    # puts "lines length #{lines.length}" 
+    if !lines.empty?
+     data = Nokogiri::XML(lines.join)
+     data.root.xpath('//Iteration').each do |iteration|
+      
+       # puts JSON::pretty_generate(iteration)
+        query_id = iteration.xpath('Iteration_query-ID').text
+
+        full_query_length = iteration.xpath('Iteration_query-len').text
+        query_def = iteration.xpath('Iteration_query-def').text
+      
+        if query_def =~ /^([^\s]+)/
+        	query_def=$1
+        end
+      
+                        #@query_def = iteration['Iteration_query-def'][0]            
+
+        query = BlastQuery.new(query_id)
+        query.query_def = query_def
+        query.full_query_length = full_query_length
+        @querys.push query
+      
+
+        hits = iteration.xpath('Iteration_hits/Hit')
+        if !hits.nil?
+  				  hits.each do |h|
+  			 				#puts JSON::pretty_generate(h)
+
+
+				               
+  				       subject_id=h.xpath('Hit_id').text
+  				       acc =h.xpath('Hit_accession').text
+  				       full_subject_length = h.xpath('Hit_len').text.to_i
+  				       hit_def=h.xpath('Hit_def').text
+  				       if hit_def=='No definition line'
+  				       	hit_def =subject_id
+  				       end
+				       
+  				       hsps = h.xpath('Hit_hsps/Hsp')
+				       
+  				       hsps.each do |hsp|
+
+  								   q_beg=hsp.xpath('Hsp_query-from').text.to_i
+  								   q_end=hsp.xpath('Hsp_query-to').text.to_i
+  								   s_beg=hsp.xpath('Hsp_hit-from').text.to_i
+  								   s_end=hsp.xpath('Hsp_hit-to').text.to_i
+	
+  								   # creates the hit
+  								   hit = BlastHit.new(q_beg,q_end,s_beg,s_end)
+
+  								   hit.align_len=hsp.xpath('Hsp_align-len').text.to_i
+  								   hit.ident=(hsp.xpath('Hsp_identity').text.to_f/hit.align_len)*100
+  								   hit.gaps=hsp.xpath('Hsp_gaps').text.to_i
+  		 				       hit.mismatches=hsp.xpath('Hsp_midline').text.count(' ').to_i - hit.gaps
+  							     hit.e_val=hsp.xpath('Hsp_evalue').text.to_f
+  							     hit.e_val = (hit.e_val*1000).round/1000.0
+  								   hit.bit_score=hsp.xpath('Hsp_bit-score').text.to_f
+   							     hit.bit_score = (hit.bit_score*100).round/100.0
+								   
+  								   hit.score = hsp.xpath('Hsp_score').text.to_f
+  								   hit.q_frame = hsp.xpath('Hsp_query-frame').text.to_i
+  								   hit.s_frame =hsp.xpath('Hsp_hit-frame').text.to_i
+								   
+  								   hit.q_seq = hsp.xpath('Hsp_qseq').text
+  								   hit.s_seq = hsp.xpath('Hsp_hseq').text
+  								   
+								   
+  								   hit.subject_id= subject_id
+  								   hit.full_subject_length=full_subject_length
+  								   # hit.full_query_length = full_query_length
+  								   hit.definition=hit_def
+  								   hit.acc=acc
+
+  								   query.add_hit(hit)
+								   
+  							 end
+  				  end
+  				end          
+        end
+      end
+      #inspect
+    
+  end
+  
+  
+  
+  def inspect
+    
+    res = "Blast results:\n"
+    res+= '-'*20
+    res+= "\nQuerys: #{@querys.count}\n"
+    @querys.each{|q| res+=q.inspect+"\n"}
+    return res
+  end
+  
+  def find_query(querys,name_q)  
+  #  newq = querys.find{|q| ( q.find{|h| (h.subject_id)})}
+    new_q=nil
+
+    if !querys.empty?
+      new_q=querys.find{|q| (q.query_id==name_q)}
+    end
+
+    return new_q
+  end
+  
+  def empty?
+    
+    return @querys.empty?
+  end  
+  
+  def size
+    @querys.size
+  end
+  
+  attr_accessor :querys
+end

data/lib/scbi_blast/dust_masker.rb

@@ -0,0 +1,103 @@
+
+class DustQuery
+  
+  attr_accessor :query_id,:dust
+  
+  def initialize(query_id)
+    @dust=[]
+    @query_id = query_id
+  end
+  
+  def push(interval)
+    @dust.push interval
+  end
+  
+  def inspect
+    res= "Query #{query_id}:"
+    @dust.each do |d|
+      res += " from #{d[0]} to #{d[1]}"
+    end
+  end
+  
+end
+
+class DustMasker
+
+def initialize(extra_params = '')
+
+		@format = 'interval'
+    @extra_params=extra_params
+   
+end
+
+def get_cmd(extra_params = '')
+
+    cmd = 'dustmasker '+@extra_params + '-outfmt '+ @format + ' 2>/dev/null'
+    return cmd
+
+end
+
+def do_dust(seq_fasta)
+    intervals=[]
+    
+    if !seq_fasta.nil? && !seq_fasta.empty?
+      
+      if seq_fasta.is_a?(Array)
+        seq_fasta=seq_fasta.join("\n")
+      end
+      
+      cmd = get_cmd(@extra_params)
+      if !seq_fasta.index('>')
+        raise "Data passed to dust must be in fasta format"
+      end
+
+      # puts seq_fasta
+  		res=''
+
+      # Ojo, que una vez nos ibamos a volver locos buscando porque esto no devolvia todos los hits que se  encontraban al ejecutar el blast a mano, y era porque en el blast a mano le estabamos pasando la secuencia completa mientras que en el MID le estabamos pasando sólo los 20 primeros nt.
+      IO.popen(cmd,'w+') {|blast|
+         blast.sync = true
+         # blast.write(">seq\n")
+         blast.write(seq_fasta)
+         blast.close_write
+         res = blast.readlines
+         blast.close_read
+      }
+      
+      if !$?.exitstatus.nil? && $?.exitstatus>0
+        raise "Error while doing #{cmd} to seq: #{seq_fasta}"
+      end
+      # puts cmd    
+      # puts $?.class
+      # puts res
+      #parse results
+    
+      # >seq
+      # 3 - 346
+      # 354 - 683
+      # .
+    
+
+      res.each do |line|
+        # puts "LINEA:" + line
+        if line =~ /^>(.*)$/ 
+          intervals.push DustQuery.new($1)
+        elsif line =~ /^(\d+)\s\-\s(\d+)/
+          # puts "Algo #{$1}, #{$2}"
+          intervals.last.push [$1.to_i,$2.to_i]
+        end
+      
+      end
+    end
+    
+    return intervals
+
+end
+
+def close
+	
+end
+
+end
+
+

data/script/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# File: script/console
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+libs =  " -r irb/completion"
+# Perhaps use a console_lib to store any extra methods I may want available in the cosole
+# libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
+libs <<  " -r #{File.expand_path(File.join(File.dirname(__FILE__),'..','lib','scbi_blast.rb'))}"
+puts "Loading scbi_blast gem"
+exec "#{irb} #{libs} --simple-prompt"