viral_seq 1.8.1.1 → 1.9.0

data/lib/viral_seq/hivdr.rb

@@ -154,7 +154,7 @@ module ViralSeq
         s = ViralSeq::Sequence.new(name,seq)
         s.translate(rf_label)
         aa[name] = s.aa_string
-        record = s.sdrm(:hiv_pr)
+        record = s.sdrm(:PI)
         mut_com << record
         record.each do |position,mutation|
           if mut[position]
@@ -386,7 +386,7 @@ module ViralSeq
         s = ViralSeq::Sequence.new(name,seq)
         s.translate(rf_label)
         aa[name] = s.aa_string
-        record = s.sdrm(:hiv_in, start_codon_number)
+        record = s.sdrm(:INSTI, start_codon_number)
         mut_com << record
         record.each do |position,mutation|
           if mut[position]
@@ -460,5 +460,209 @@ module ViralSeq
       return [point_mutation_list, linkage_list, report_list]
     end
 
+
+    # wrapper function for #a3g_hypermut and #stop_codon with ViralSeq::DrmRegionConfig as a param.
+
+    def filter_for_drm(region_config)
+      seq_coord = region_config.seq_coord
+      reading_frame_number = region_config.get_reading_frame_number
+
+      if !seq_coord["gap"]
+
+        a3g_check = self.a3g
+        a3g_seqs = a3g_check[:a3g_seq]
+        a3g_filtered_seqs = a3g_check[:filtered_seq]
+
+        stop_codon_check = a3g_filtered_seqs.stop_codon(reading_frame_number[0])
+        stop_codon_seqs = stop_codon_check[:with_stop_codon]
+        filtered_seqs = stop_codon_check[:without_stop_codon]
+
+        return {
+          filtered_seq: filtered_seqs,
+          a3g_seq: a3g_seqs,
+          stop_codon_seq: stop_codon_seqs
+        }
+
+      else
+
+        r1_length, r2_length = region_config.r1_r2_length.values
+
+        r1_seqs = {}
+        r2_seqs = {}
+
+        self.dna_hash.each do |k,v|
+            r1_seqs[k] = v[0,r1_length]
+            r2_seqs[k] = v[r1_length, r2_length]
+        end
+
+        r1_sh = ViralSeq::SeqHash.new(r1_seqs)
+        r2_sh = ViralSeq::SeqHash.new(r2_seqs)
+
+        a3g_seqs_r1 = r1_sh.a3g[:a3g_seq]
+        a3g_seqs_r2 = r2_sh.a3g[:a3g_seq]
+
+        stop_codon_r1 = r1_sh.stop_codon(reading_frame_number[0])[:with_stop_codon]
+        stop_codon_r2 = r2_sh.stop_codon(reading_frame_number[1])[:with_stop_codon]
+
+        a3g_seq_keys = (a3g_seqs_r1.dna_hash.keys | a3g_seqs_r2.dna_hash.keys)
+        a3g_seqs = ViralSeq::SeqHash.new(self.dna_hash.select {|k, _v| a3g_seq_keys.include? k})
+
+        stop_codon_keys = (stop_codon_r1.dna_hash.keys | stop_codon_r2.dna_hash.keys)
+        stop_codon_seqs = ViralSeq::SeqHash.new(self.dna_hash.select {|k, _v| stop_codon_keys.include? k})
+
+        reject_keys = (a3g_seq_keys | stop_codon_keys)
+
+        filtered_seqs = ViralSeq::SeqHash.new(self.dna_hash.reject { |k, _v| reject_keys.include? k })
+
+        return {
+          filtered_seq: filtered_seqs,
+          a3g_seq: a3g_seqs,
+          stop_codon_seq: stop_codon_seqs
+        }
+
+      end
+
+    end # end of #filter_for_drm
+
+
+    # insert the partial genome into the whole gene for HIV resistance analysis
+
+
+    def complete_with_ref(region_config)
+      complete_seqs = {}
+      seq_coord = region_config.seq_coord
+
+      ref = ViralSeq::RefSeq.get(region_config.ref_info["ref_type"].to_sym)
+      a = region_config.ref_info["ref_coord"][0]
+      b = region_config.ref_info["ref_coord"][1]
+      c = seq_coord["minimum"]
+      d = seq_coord["maximum"]
+
+      if seq_coord["gap"]
+        e = seq_coord["gap"]["minimum"]
+        f = seq_coord["gap"]["maximum"]
+
+        self.dna_hash.each do |k,v|
+          complete_seqs[k] = ref[(a-1)..(c-2)] + v[0,(e-c)] + ref[(e-1)..(f-1)] + v[(e-c)..-1] + ref[d..(b-1)]
+        end
+      else
+        self.dna_hash.each do |k,v|
+          complete_seqs[k] = ref[(a-1)..(c-2)] + v + ref[d..(b-1)]
+        end
+      end
+
+      return ViralSeq::SeqHash.new(complete_seqs)
+    end #end of #complete_with_ref
+
+
+    # function to interpret HIV drms with ViralSeq::DrmRegionConfig as a param.
+
+    def drm(region_config)
+      region = region_config.region
+      fdr_hash = self.fdr # must run fdr before the completion of the sequences
+
+      complete_gene = self.complete_with_ref(region_config)
+      sequences = complete_gene.dna_hash
+
+      n_seq = sequences.size
+      aa = {}
+      mut = {}
+      mut_com = []
+      point_mutation_list = []
+
+      drm_list = region_config.drm_list
+
+      sequences.each do |name, seq|
+        s = ViralSeq::Sequence.new(name, seq)
+        s.translate
+        aa[name] = s.aa_string
+
+        records_per_seq = {}
+
+        drm_list.each do |drm_class, list|
+
+          mut[drm_class] = {}  if !mut[drm_class]
+
+          record = s.check_drm(list)
+          records_per_seq = records_per_seq.merge(record)
+
+          record.each do |position, mutation|
+            if !mut[drm_class][position]
+              mut[drm_class][position] = [mutation[0],[]]
+            end
+            mut[drm_class][position][1] << mutation[1]
+          end
+        end
+
+        mut_com << records_per_seq.sort.to_h
+      end
+
+      mut.each do |drm_class, mutations|
+        mutations.each do |position, mutation|
+          wt = mutation[0]
+          mut_list = mutation[1]
+          count_mut_list = mut_list.count_freq
+          count_mut_list.each do |m,number|
+            ci = ViralSeq::Math::BinomCI.new(number, n_seq)
+            fdr = fdr_hash[number].round(5)
+            label = fdr >= 0.05 ? "*" : ""
+            point_mutation_list << [drm_class, n_seq, position, wt, m, number, ci.mean.round(5), ci.lower.round(5), ci.upper.round(5), fdr, label]
+          end
+        end
+      end
+
+      point_mutation_list.sort_by! {|record| record[2]}
+
+      link = mut_com.count_freq
+      link2 = {}
+      link.each do |k,v|
+        pattern = []
+        if k.size == 0
+          pattern = ['WT']
+        else
+          k.each do |p,m|
+            pattern << (m[0] + p.to_s + m[1])
+          end
+        end
+        link2[pattern.join("+")] = v
+      end
+      linkage_list = []
+      link2.sort_by{|_key,value|value}.reverse.to_h.each do |k,v|
+        ci = ViralSeq::Math::BinomCI.new(v, n_seq)
+        label = ""
+        linkage_list << [region, n_seq, k, v, ci.mean.round(5), ci.lower.round(5), ci.upper.round(5), label]
+      end
+
+      report_list = []
+
+      div_aa = {}
+      aa_start = 1
+
+      aa_size = aa.values[0].size - 1
+
+      (0..aa_size).to_a.each do |p|
+        aas = []
+        aa.values.each do |r1|
+          aas << r1[p]
+        end
+        count_aas = aas.count_freq
+        div_aa[aa_start] = count_aas.sort_by{|_k,v|v}.reverse.to_h
+        aa_start += 1
+      end
+
+      div_aa.each do |k,v|
+        record = [region, k, n_seq]
+        ViralSeq::AMINO_ACID_LIST.each do |amino_acid|
+          aa_count = v[amino_acid]
+          record << (aa_count.to_f/n_seq*100).round(4)
+        end
+        report_list << record
+      end
+
+      return [point_mutation_list, linkage_list, report_list]
+
+    end
+
   end # end of ViralSeq::SeqHash
+
 end # end of ViralSeq

data/lib/viral_seq/sdrm.rb

@@ -1,109 +1,44 @@
 module ViralSeq
   class DRMs
-    class << self
 
-      # function to retrieve sdrm positions as a hash
-      # @param ref_option [Symbol], name of reference genomes, options are `:hiv_pr`, `:hiv_rt`, `:hiv_in`, `hcv_ns5a`
-      # @return [Hash] Hash of :position_number => [ 'wildtype_codon', ['mutation_codons']]
-      def sdrm_hash(options)
+    # function to retrieve sdrm positions as a hash, DRM list are stored at `lib/viral_seq/util/drm_list.json`
+    # @param ref_option [Symbol], name of reference genomes, options are `:hiv_pr`, `:hiv_rt`, `:hiv_in`, `hcv_ns5a`
+    # @return [Hash] Hash of :position_number => [ 'wildtype_codon', ['mutation_codons']]
+
+    def self.sdrm_hash(options)
+      options = options.to_s.upcase
+      drm_data = JSON.parse(
+        File.read(
+          File.join(ViralSeq.root, 'viral_seq', 'util', 'drm_list.json')
+        )
+      )
+      if drm_data[options]
         sdrm = {}
-        case options
-        when :hcv_ns5a
-          sdrm[28] = ['M',['T']]
-          sdrm[30] = ['L',['H','K','R','Q','A','S','D']]
-          sdrm[31] = ['L',['M','V','F']]
-          sdrm[32] = ['P',['L']]
-          sdrm[44] = ['K',['R']]
-          sdrm[58] = ['H',['D','P','S']]
-          sdrm[64] = ['T',['A','S']]
-          sdrm[77] = ['P',['A','S']]
-          sdrm[78] = ['R',['K']]
-          sdrm[79] = ['T',['A']]
-          sdrm[83] = ['T',['M']]
-          sdrm[85] = ['S',['N','H','Y']]
-          sdrm[92] = ['A',['P','T','K','E']]
-          sdrm[93] = ['Y',['C','F','H','N']]
-          sdrm[107] = ['K',['T','S']]
-          sdrm[121] = ['I',['V']]
-          sdrm[135] = ['T',['A']]
-        when :nrti
-          sdrm[41] = ['M',['L']]
-          sdrm[65] = ['K',['R']]
-          sdrm[67] = ['D',['N','G','E']]
-          sdrm[69] = ['T',['D']]
-          sdrm[70] = ['K',['R','E']]
-          sdrm[74] = ['L',['V','I']]
-          sdrm[75] = ['V',['M','T','A','S']]
-          sdrm[77] = ['F',['L']]
-          sdrm[115] = ['Y',['F']]
-          sdrm[116] = ['F',['Y']]
-          sdrm[151] = ['Q',['M']]
-          sdrm[184] = ['M',['V','I']]
-          sdrm[210] = ['L',['W']]
-          sdrm[215] = ["T",["Y","F","I","C","D","V","E"]]
-          sdrm[219] = ["K",["Q","E","N","R"]]
-        when :nnrti
-          sdrm[100] = ['L',['I']]
-          sdrm[101] = ['K',['E','P']]
-          sdrm[103] = ['K',['N','S']]
-          sdrm[106] = ['V',['M','A']]
-          sdrm[179] = ['V',['F','D']]
-          sdrm[181] = ['Y',['C','I','V']]
-          sdrm[188] = ['Y',['L','H','C']]
-          sdrm[190] = ['G',['A','S','E']]
-          sdrm[225] = ['P',['H']]
-          sdrm[230] = ['M',['L']]
-        when :hiv_pr
-          sdrm[23] = ['L',['I']]
-          sdrm[24] = ['L',['I']]
-          sdrm[30] = ['D',['N']]
-          sdrm[32] = ['V',['I']]
-          sdrm[46] = ['M',['I','L']]
-          sdrm[47] = ['I',['V','A']]
-          sdrm[48] = ['G',['V','M']]
-          sdrm[50] = ['I',['V','L']]
-          sdrm[53] = ['F',['L']]
-          sdrm[54] = ['I',['V','L','M','T','A','S']]
-          sdrm[73] = ['G',['S','T','C','A']]
-          sdrm[76] = ['L',['V']]
-          sdrm[82] = ['V',['A','T','S','F','L','C','M']]
-          sdrm[83] = ['N',['D']]
-          sdrm[84] = ['I',['V','A','C']]
-          sdrm[88] = ['N',['D','S']]
-          sdrm[90] = ['L',['M']]
-        when :hiv_in
-          sdrm[66] = ['T',['A','I','K']]
-          sdrm[74] = ['L',['M']]
-          sdrm[92] = ['E',['Q']]
-          sdrm[95] = ['Q',['K']]
-          sdrm[97] = ['T',['A']]
-          sdrm[121] = ['F',['Y']]
-          sdrm[140] = ['G',['A','S','C']]
-          sdrm[143] = ["Y",["C","H","R"]]
-          sdrm[147] = ['S',['G']]
-          sdrm[148] = ['Q',['H','K','R']]
-          sdrm[155] = ['N',['S','H']]
-        else raise "Input option `#{options}` for ViralSeq::Sequence.sdrm not supported"
+        drm_data[options].each do |record|
+          sdrm[record["position"]] = [record["wild-type"], record["mutations"]]
         end
-        return sdrm
-      end # end of #sdrm_hash
 
-      # function to export SDRM positions as json object
-      # @param (see #sdrm_hash)
-      # @return [Array] json Array of SDRM positions
+      else
+        abort "Input option `#{options}` for ViralSeq::DRMs.sdrm_hash not supported. Program aborted.\nSupported type of mutations for '#{drm_data.keys.join(", ")}' only."
+      end
+      return sdrm
+    end # end of #sdrm_hash
+
+    # function to export SDRM positions as json object
+    # @param (see #sdrm_hash)
+    # @return [Array] json Array of SDRM positions
 
-      def sdrm_json(options)
-        sdrm = ViralSeq::DRMs.sdrm_hash(options)
-        json_array = []
-        sdrm.each do |pos, muts|
-          mutation = {}
-          mutation[:position] = pos
-          mutation[:wildtypeCodon] = muts[0]
-          mutation[:mutationCodons] = muts[1]
-          json_array << mutation
-        end
-        return json_array
+    def self.sdrm_json(options)
+      sdrm = ViralSeq::DRMs.sdrm_hash(options)
+      json_array = []
+      sdrm.each do |pos, muts|
+        mutation = {}
+        mutation[:position] = pos
+        mutation[:wildtypeCodon] = muts[0]
+        mutation[:mutationCodons] = muts[1]
+        json_array << mutation
       end
-    end
+      return json_array
+    end #end of #sdrm_json
   end
 end

data/lib/viral_seq/sequence.rb

@@ -136,7 +136,32 @@ module ViralSeq
         end
       end
       return out_hash
-    end # end of #hcv_ns5a
+    end # end of #sdrm
+
+    # Similar to #sdrm but use a DRM list as a param
+
+    def check_drm(drm_list_single_type)
+      aa_array = self.aa_array
+      out_hash = {}
+
+      drm_list_single_type.each do |position, mut|
+        wt_aa = mut[0]
+        mut_aas = mut[1]
+        test_aa = aa_array[position - 1]
+        if test_aa.size == 1 and mut_aas.include?(test_aa)
+          out_hash[position] = [wt_aa, test_aa]
+        elsif test_aa.size > 1
+          test_aa_array = test_aa.split("")
+          mut_detected = test_aa_array & mut_aas
+
+          if !mut_detected.empty?
+            out_hash[position] = [wt_aa, mut_detected.join]
+          end
+
+        end
+      end
+      return out_hash
+    end
 
     # HIV sequence locator function, resembling HIV Sequence Locator from LANL
     #   # current version only supports nucleotide sequence, not for amino acid sequence.

data/lib/viral_seq/tcs_core.rb

@@ -126,7 +126,7 @@ module ViralSeq
         name_array.each do |name|
           tag = parser_file_name(name)[:tag]
           if name !~ /\.fastq\Z|\.fastq\.gz\Z/
-            errors[:file_type_error] << name
+            name_array.delete(name)
           elsif tag.count("R1") == 0 and tag.count("R2") == 0
             errors[:no_region_tag] << name
           elsif tag.count("R1") > 0 and tag.count("R2") > 0

data/lib/viral_seq/tcs_dr.rb

@@ -5,7 +5,7 @@ module ViralSeq
   # run `tcs --dr_params [VERSION]` to pull the params json string for each version of DR.
   module TcsDr
     PARAMS = {
-      "v1" => {:platform_error_rate=>0.02,
+      "v1" => {:platform_error_rate=>0.01,
       :primer_pairs=>
        [{:region=>"RT",
          :cdna=>
@@ -68,7 +68,7 @@ module ViralSeq
          :ref_end=>7205..7210,
          :indel=>true,
          :trim=>false},
-         {:region=>"P17",
+         {:region=>"CA",
           :cdna=>
            "GTGACTGGAGTTCAGACGTGTGCTCTTCCGATCTNNNNNNNNNNNCAGTCAACAAGGTTTCTGTCATCCAATTTTTTAC",
           :forward=>
@@ -86,7 +86,7 @@ module ViralSeq
          ]
       },
 
-      "v2" => {:platform_error_rate=>0.02,
+      "v2" => {:platform_error_rate=>0.01,
       :primer_pairs=>
       [{:region=>"RT",
         :cdna=>
@@ -149,7 +149,7 @@ module ViralSeq
         :ref_end=>7205..7210,
         :indel=>true,
         :trim=>false},
-        {:region=>"P17",
+        {:region=>"CA",
           :cdna=>
           "GTGACTGGAGTTCAGACGTGTGCTCTTCCGATCTNNNNNNNNNNNCAGTCAACAAGGTTTCTGTCATCCAATTTTTTAC",
           :forward=>
@@ -165,7 +165,89 @@ module ViralSeq
           :indel=>true,
           :trim=>false}
         ]
-      }
+      },
+
+      "v3" => {:platform_error_rate=>0.01,
+      :primer_pairs=>
+      [{:region=>"RT",
+        :cdna=>
+          "GTGACTGGAGTTCAGACGTGTGCTCTTCCGATCTNNNNNNNNNNNCAGTAAGGAATGGAGGTTCTTTCTGATG",
+        :forward=>
+          "GCCTCCCTCGCGCCATCAGAGATGTGTATAAGAGACAGNNNNGGCCATTGACAGAAGAAAAAATAAAAGC",
+        :majority=>0,
+        :end_join=>true,
+        :end_join_option=>1,
+        :overlap=>0,
+        :TCS_QC=>true,
+        :ref_genome=>"HXB2",
+        :ref_start=>2648,
+        :ref_end=>3209,
+        :indel=>true,
+        :trim=>false},
+        {:region=>"PR",
+        :cdna=>
+          "GTGACTGGAGTTCAGACGTGTGCTCTTCCGATCTNNNNNNNNNTTAACCTTTGGGCCATCCATTCC",
+        :forward=>
+          "GCCTCCCTCGCGCCATCAGAGATGTGTATAAGAGACAGNNNNTCAGAGCAGACCAGAGCCAACAGCCCCA",
+        :majority=>0,
+        :end_join=>true,
+        :end_join_option=>3,
+        :TCS_QC=>true,
+        :ref_genome=>"HXB2",
+        :ref_start=>0,
+        :ref_end=>2591,
+        :indel=>true,
+        :trim=>true,
+        :trim_ref=>"HXB2",
+        :trim_ref_start=>2253,
+        :trim_ref_end=>2549},
+        {:region=>"IN",
+        :cdna=>
+          "GTGACTGGAGTTCAGACGTGTGCTCTTCCGATCTNNNNNNNNNNNCACAATCAKCACCTGCCATCTG",
+        :forward=>"GCCTCCCTCGCGCCATCAGAGATGTGTATAAGAGACAGNNNNGCAGAAGTTATYCCAGCAGAAACA",
+        :majority=>0,
+        :end_join=>true,
+        :end_join_option=>3,
+        :TCS_QC=>true,
+        :ref_genome=>"HXB2",
+        :ref_start=>4509,
+        :ref_end=>5048,
+        :indel=>true,
+        :trim=>false},
+        {:region=>"V1V3",
+        :cdna=>
+          "GTGACTGGAGTTCAGACGTGTGCTCTTCCGATCTNNNNNNNNNNNCAGTCCATTTTGCTYTAYTRABVTTACAATRTGC",
+        :forward=>
+          "GCCTCCCTCGCGCCATCAGAGATGTGTATAAGAGACAGNNNNTTATGGGATCAAAGCCTAAAGCCATGTGTA",
+        :majority=>0,
+        :end_join=>true,
+        :end_join_option=>1,
+        :overlap=>0,
+        :TCS_QC=>true,
+        :ref_genome=>"HXB2",
+        :ref_start=>6585,
+        :ref_end=>7205..7210,
+        :indel=>true,
+        :trim=>false},
+        {:region=>"CA",
+          :cdna=>
+          "GTGACTGGAGTTCAGACGTGTGCTCTTCCGATCTNNNNNNNNNNNCAGTCAACAAGGTTTCTGTCATCCAATTTTTTAC",
+          :forward=>
+          "GCCTCCCTCGCGCCATCAGAGATGTGTATAAGAGACAGNNNNGTCAGCCAAAATTACCCTATAGTGC",
+          :majority=>0,
+          :end_join=>true,
+          :end_join_option=>1,
+          :overlap=>0,
+          :TCS_QC=>true,
+          :ref_genome=>"HXB2",
+          :ref_start=>1196,
+          :ref_end=>1725,
+          :indel=>true,
+          :trim=>false}
+        ]
+      },
+
+
     }
 
   end