bio-sam-mutation 0.4.1

data/lib/bio-sam-mutation/bio/alignment/iterate_pairs.rb

@@ -0,0 +1,68 @@
+module Bio::Alignment::IteratePairs
+	private
+	#Mixin to iterate through ordered paired [operation, value] data and take subsets - e.g. broken down CIGAR and MD:Z tags.
+	#Can set a regexp for the operation; default matches everything
+	def iterate_pairs(pairs,offset,length,regexp = //)
+		offset = offset.to_i
+		length - length.to_i
+		total = 0
+		new_array = []
+		first = true
+		pairs.each do |pair|
+			new_pair = pair.dup
+			if pair[1].is_a? String
+				pairlength = pair[1].length
+			elsif pair[1].is_a? Integer
+				pairlength = pair[1]
+			else
+				raise "Value for operation must be a string or integer"
+			end
+			# Only count pairs where first element matches a regexp.
+			# e.g. for CIGAR:
+			# ref M + ref D = ref length
+			# query M + query I = query length
+			if pair[0].match(regexp)
+				total += pairlength
+			end
+			# Just keep going until we get to the start of the subalignment
+			if total < offset
+				next
+			end
+			# If the offset is partway through a pair, need to split it up.
+			if first
+				# adjust the number in this pair; it will be added below
+				if pair[1].is_a? String
+					new_pair[1] = new_pair[1][total-offset..pairlength]
+				else
+					new_pair[1] = total - offset + 1  # Add one for bases
+				end
+			end
+
+			# Once we are at/beyond the end of the desired region:
+			if total >= offset + length
+				# Special case where the whole subalignment is contained within one cigar element:
+				if first
+					if pair[1].is_a? String
+						new_pair[1] = new_pair[1][total-offset-pairlength,length]
+					else
+						new_pair[1] = length
+					end
+					new_array << new_pair
+					break
+				end
+			# Adding the last part of the alignment
+				previous_total = total - pairlength
+				if pair[1].is_a? Integer
+					new_pair[1] = offset + length - previous_total - 1 #-1 extra for base arithmetic
+				else
+					new_pair[1] = new_pair[1][0..offset + length - previous_total]
+				end
+				new_array << new_pair
+				break
+			end
+			first = false
+			new_array << new_pair
+		end
+		new_array
+	end
+end

data/lib/bio-sam-mutation/bio/db/alignment.rb

@@ -0,0 +1,176 @@
+# Extending Bio::DB::Alignment with mutation calling method
+Bio::DB::Alignment.class_eval do
+	# Aliases included for more intuitive naming when using for genomic alignments:
+	alias_method :chr, :rname
+	alias_method :opt, :tags # vice versa as opt is the "proper" sam name for the tag fields
+	attr_accessor :cigar_obj
+
+	def add_tag!(new_tag)
+		if new_tag.is_a? String
+			new_tag = Bio::DB::Tag.new(new_tag)
+			# new_tag_obj.set(new_tag)
+			# new_tag = new_tag_obj
+		else
+			raise "Tag not recognised - pass a string or Bio::DB::Tag object" unless new_tag.is_a? Bio::DB::Tag
+		end
+		@tags[new_tag.tag] = new_tag
+
+		regenerate_string
+	end
+
+	def add_tag(tag)
+		dup.add_tag!(tag)
+	end
+
+	# Output a representation of the query sequence
+	def query offset=1, length=@seq.length, reference_pos=@pos-1, ins_chr="_"
+	  mutations = self.mutations(offset,length)
+		cigar = Bio::Alignment::CIGAR.new(@cigar,seq,source="sam")
+		preceding = cigar.subalignment(0,offset-1)
+		preceding_diff = preceding.query_length-(offset-1)
+		pointer = preceding.query_length
+		output = []
+		deletions = 0
+		insertions = 0
+		if mutations
+			mutations.each do |mut|
+				mut.position = mut.position + insertions - deletions + preceding_diff
+				case mut.type
+					when :deletion
+						# position for deletion is the first deleted base
+						fillin = mut.position-1-reference_pos-1
+				    output << @seq[pointer..fillin] if fillin > pointer
+						mut.reference.length.times{ output << "-" }
+						pointer += fillin - pointer + 1
+						deletions += mut.reference.length
+					when :insertion
+						# position for insertion is the base we want
+						fillin = mut.position-reference_pos-1
+						output << @seq[pointer..fillin] if fillin > pointer
+						output << ins_chr + mut.mutant.downcase + ins_chr
+						pointer += fillin - pointer + 1 + mut.mutant.length
+						insertions += mut.mutant.length
+					when :substitution
+						# position for substitution is the first subbed base
+						fillin = mut.position-1-reference_pos-1
+				    output << @seq[pointer..fillin] if fillin > pointer
+						output << mut.mutant.downcase
+						pointer += fillin - pointer + 1 + mut.mutant.length
+				end
+			end
+		end
+		# Remaining sequence
+		if offset + length > pointer
+      output << @seq[pointer..offset-1+length-1-deletions+insertions+preceding_diff]
+		end
+		output.join
+	end
+
+  # Call mutations
+  # Want to be able to give a length and offset - use this to generate appropriate sub CIGARs, subMDs & call
+	def mutations offset=1, length=nil, translation_start=1
+		return nil if @query_unmapped
+		cigar = Bio::Alignment::CIGAR.new(@cigar,seq,source="sam")
+		length ||= cigar.reference_length - offset
+		return nil if offset+length > cigar.reference_length
+		seq = Bio::Sequence::NA.new(@seq)
+		@cigar_obj = cigar
+    # Generate subalignments from the CIGAR and MD:Z
+    subcigar = cigar.subalignment(offset,length)
+    mdz = Bio::DB::Tag::MD.new(@tags["MD"].value)
+		mdz = mdz.slice(offset,length)
+    # Get inserted bases from the read sequence, only within the region of interest
+    insertions = []
+    insertion_positions = subcigar.positions(/I/)
+    unless insertion_positions.empty?
+      insertion_positions["I"].each do |ins|
+        # Sam.seq returns a Sequence::NA object
+        # Need a -1 as ruby counts characters
+        # Use ins[2] to retrieve the base as this is the position on query. ins[1] is position on reference, used to annotate position.
+        i = seq.seq[(offset+ins[2]-1),ins[1]]
+        insertions << i
+      end
+    end
+
+    first_match = true
+		total = 0
+		mutations = []
+		reference_pos = @pos - 1
+		subcigar.pairs.each do |pair|
+			case pair[0]
+				when "M"
+					#break if first_match == false
+					reference_pos += pair[1]
+					total += pair[1]
+					first_match = false
+        # Call deletions using the MD:Z tag - avoid need to supply reference seq.
+				when "D"
+				# Deletions are called below but still need to count here
+				  reference_pos += pair[1]
+				when "I"
+					mut = Bio::Mutation.new
+					mut.type = :insertion
+					mut.reference = nil
+					mut.position = reference_pos + offset - translation_start
+					bases = insertions.shift
+					mut.mutant = bases ? bases.upcase : "N"
+					mut.seqname = @rname.to_s
+          mutations << mut
+			end
+		end
+
+    # Now substitutions & deletions - these need the MD tag
+    sub_pos = mdz.report(/[sd]/)
+		previous_sub_position = 0
+		unless sub_pos.empty?
+			sub_pos.each do |p|
+				# Reference base is in the MD:Z tag (p[1] here), for the actual base need to go to the read
+				# p[3] is the length of operations preceding the substitution on the read, p[2] on the reference.
+				# p[2] and p[3] are defined on the subalignment, so should add them onto the preceding.
+				# Need to add in any inserted bases from the CIGAR string using query_length
+				preceding = cigar.subalignment(0,offset-1)
+				# Masked length is not included in the MD:Z string so need to add it
+				read_position = preceding.query_length+preceding.masked_length+p[3]
+        # This is the adjustment needed to get the correct annotation:
+        substart = @pos + offset - translation_start - 1
+        case p[0]
+          when "s"
+            mut = Bio::Mutation.new
+            mut.type = :substitution
+            mut.position = substart+p[2] + 1
+            mut.reference = p[1].upcase
+            mut.mutant = seq[read_position,p[1].length].upcase
+						mut.seqname = @rname.to_s
+            mutations << mut
+          when "d"
+            mut = Bio::Mutation.new
+  					mut.type = :deletion
+  					mut.reference = p[1].upcase
+  					mut.position = substart+p[2] + 1
+  					mut.mutant = nil
+						mut.seqname = @rname.to_s
+  					mutations << mut
+        end
+      end
+    end
+    # mutations.length > 0 ? mutations.sort{|x,y| x.position.to_i <=> y.position.to_i} : nil
+    mutations.length > 0 ? Bio::MutationArray.new(mutations.sort) : nil
+
+  end
+
+	def regenerate_string
+		tags_string = @tags.map{|k,v| [v.tag, v.type, v.value].join(":") }
+		self.sam_string = [@qname,
+	        @flag,
+	        @rname,
+	        @pos,
+	        @mapq,
+	        @cigar,
+	        @mrnm,
+	        @mpos,
+	        @isize,
+	        @seq,
+	        @qual,
+	        tags_string].join("\t")
+	end
+end

data/lib/bio-sam-mutation/bio/db/tag.rb

@@ -0,0 +1,5 @@
+Bio::DB::Tag.class_eval do
+  def initialize(tag_string=nil)
+      set(tag_string) if tag_string
+  end
+end

data/lib/bio-sam-mutation/bio/db/tag/md.rb

@@ -0,0 +1,126 @@
+class Bio::DB::Tag::MD
+	include Bio::Alignment::IteratePairs
+	attr_accessor :tag, :pairs, :cumulative
+	@@regexp = /MD:Z:([\w^]+)/
+	@@format = /[\w^]+/
+	@@splitter = /(?<match>\d+)|(?<substitution>[GATCN]+)|\^(?<deletion>[GATCN]+)/
+	# Operations that consume reference seqeunce:
+	@@reference = /[msd]/
+	def initialize(data)
+			if data.is_a? String
+				if data.match(@@regexp)
+					@tag = $~[1]
+				elsif data.match(@@format)
+					#Assume tag given without MD:Z: leader
+					@tag = data
+				else
+					raise "Tag not of expected format."
+				end
+			elsif data.is_a? Bio::DB::Tag
+				@tag = data.value
+				warn "Not an MD tag" if data.tag == "MD"
+			else
+				raise "Tag not of expected format."
+			end
+
+		# Splits the string into operations using the splitter regexp class variable, returns array of two-element arrays describing operations
+		spl = @tag.scan(@@splitter)
+		# Returns an array of matches [match,substition,deletion]
+		# Although regexp captures are named, these don't get included automatically with scan as it doesn't return MatchData objects.
+		spl.map! do |a|
+			array = [["m", a[0]],["s", a[1]],["d", a[2]]]
+			# Only one of these will be non-nil
+			array.keep_if{|i| i[1]}
+			array.map!{|i| if i[0] == "m" then i[1] = i[1].to_i end; i}
+			array[0]
+		end
+		@pairs = spl
+
+		@cumulative = []
+		cumulative_length = 0
+		read_length = 0
+		@pairs.each do |q|
+			p = q.dup
+			case p[0]
+				when "m"
+					len = p[1]
+					rlen = p[1]
+				when "s"
+					len = p[1].length
+					rlen = p[1].length
+				when "d"
+					len = p[1].length
+					# Deleted bases don't appear in the read, so don't count to the length
+					rlen = 0
+			end
+			# third element in each array will be the total preceding length on the reference, i.e. the position of the operation.
+			# fourth element is similar for the read.
+			@cumulative << p.dup.push(cumulative_length).push(read_length)
+			cumulative_length += len
+			read_length += rlen
+		end
+	end
+
+	def deletions
+		report(/d/)
+	end
+
+	def substitutions
+		report(/s/)
+	end
+
+	# Report the positions of given events
+	def report(regexp=/[sd]/)
+		to_return = []
+		@cumulative.each do |p|
+			if p[0] =~ regexp
+				to_return << p
+			end
+		end
+		to_return
+	end
+
+	# Reconstruct a MD:Z tag from the pairs array
+	def reconstruct_tag(array=@pairs)
+		new_tag = []
+		array.each do |p|
+			case p[0]
+				when "m"
+					string = p[1].to_s
+				when "s"
+					string = p[1]
+				when "d"
+					string = "^"+p[1]
+			end
+			new_tag << string
+		end
+		new_tag.join("")
+	end
+
+
+
+	# Sums the total length of the reference sequence represented by the MD:Z tag (or part of)
+	def ref_length
+		#Need the sum of all "movement" operations (i.e. numbers) as well as any substituted bases (count 1 each)
+		if @tag =~ /^\d+$/
+			@tag.to_i
+		else
+			temp_tag = @tag.dup
+			temp_tag.gsub!(/\^/,"")  # Deletions need to be counted - sub the caret character out and count the remaining base characters
+			movements = temp_tag.split(/[GATCN]+/).map(&:to_i).reduce(:+) # Sum numbers
+			deletions = temp_tag.split(/\d+/).map(&:length).reduce(:+) # Sum number of base chars
+			movements + deletions
+		end
+	end
+	# Given an offset in reference sequence and length, return an object corresponding to that subregion of the alignment
+	def slice(offset,length)
+		new_array = iterate_pairs(@pairs,offset,length,@@reference)
+		# Return a MDZ instance with just the new alignment
+		new_tag = reconstruct_tag(new_array)
+		Bio::DB::Tag::MD.new(new_tag)
+	end
+
+end
+
+
+# DKNQZ:00025:00303       0       5       112767204       37      60M1D7M2I6M     *       0       0       GCAGTAATTTCCCTGGAGTAAAACTGCGGTCAAAAATGTCCCTCCGTTCTTATGGAAGCCGGAAGGAAGTCTGTA     CCCCCC@CE>CC<CC@CB;;;;.;;;;;AC;::::+:92A:=CCAEE=?>;=:@<B?:<6<*/*/*/*/911112     XT:A:U  NM:i:3  X0:i:1  X1:i:0  XM:i:3  XO:i:1  XG:i:1  MD:Z:60^G13

data/lib/bio-sam-mutation/bio/mutantallele.rb

@@ -0,0 +1,24 @@
+# Used for tracking mutations appearing more than once and cacheing VEP lookups
+class MutantAllele
+  attr_accessor :mutations, :count, :example, :seq
+  class << self
+    attr_accessor :previous_lookups
+  end
+  self.previous_lookups = {}
+
+  def initialize (mutations: nil, count: 0, example: nil, seq: nil)
+    @mutations = mutations
+    @count = count
+    @example = example
+  end
+
+  # Returns JSON from Ensembl VEP
+  def lookup species="human", ref_type=nil
+    key = mutations.to_hgvs(ref_type)
+    if key && (MutantAllele.previous_lookups.keys.include? key)
+      MutantAllele.previous_lookups[key]
+    else
+      mutations.vep(species,ref_type)
+    end
+  end
+end

data/lib/bio-sam-mutation/bio/mutation.rb

@@ -0,0 +1,63 @@
+class Bio::Mutation
+  include VepHgvs
+  attr_accessor :position, :type, :reference, :mutant, :seqname
+  def initialize params={position: 1,type: :uninitialized, reference: nil, mutant: nil, seqname: nil}
+    @position = params[:position]
+    @type = params[:type]
+    @reference = params[:reference]
+    @mutant = params[:mutant]
+    @seqname = params[:seqname]
+  end
+
+  def <=> other
+    return 0 if self.position == other.position
+    self.position > other.position ? 1 : -1
+  end
+
+  # http://www.hgvs.org/mutnomen/recs.html
+  # This gives just the annotation. To convert to a full allele description, needs to be combined
+  # with e.g. g. for genomic:  g. - can supply this "g", "c" as type to annotate a single mutation directly
+  # for compound mutants, need to join an array of annotations e.g. 1:g.[213456A>C;213460_213461delTG]
+  def to_hgvs(reference_type=nil)
+    if reference_type
+      hgvs_arr = [@seqname,":",reference_type,".",@position.to_s]
+    else
+      hgvs_arr = [@position.to_s]
+    end
+
+    case @type
+      when :deletion
+        if @reference.length == 1
+          hgvs_arr << "del"+@reference
+        else
+          hgvs_arr = hgvs_arr + ["_",
+                                (@position.to_i+@reference.length-1).to_s,
+                                "del",
+                                @reference]
+        end
+        hgvs_arr.join
+
+      when :substitution
+        if @reference.length > 1
+          hgvs_arr = hgvs_arr + ["_",
+                                (@position.to_i+@reference.length-1).to_s]
+        end
+        hgvs_arr << @reference+">"+@mutant
+        hgvs_arr.join
+
+      when :insertion
+        hgvs_arr << "_" + (@position.to_i+1).to_s
+        hgvs_arr << "ins"+@mutant
+        hgvs_arr.join
+        # TODO - distinguish duplications from insertions? Needs further input from ref.
+    end
+  end
+
+  def to_json
+    Oj.dump self
+  end
+
+  def to_yaml
+    YAML.dump self
+  end
+end