htslib 0.0.10 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2ecf4c183a1720313371e493fbf7876a08d17639ad853b1d26faeff3addb7c6e
-  data.tar.gz: cd1ed908a5dd8be184c8d9195c6fb5fabda5487d3c35e11476d9bd6d15c7dae8
+  metadata.gz: c90062954caa8dc2155f77ff3d03534d933ba81148f9bdb7c8dc173f73efca64
+  data.tar.gz: fb24ced637a8b9b897ecd9c5afed1c6f75902995e48c25daa849baa06611517b
 SHA512:
-  metadata.gz: 4980914c7b92528055d2d0cf62fad6ca5edcde8ba1b9d426740538aee42fab53c7ef96ebe53adcaa9663368f024546c048b71760b68bd88e7cbb7647e200847c
-  data.tar.gz: a94b5d01702cc9873fdf6d1498658cff15c44ba8c90b08cafe514a883560c6aaa90cfbd83cede8a4ae1a5095c6f99710e76a8aacb0e0851e628c607c37719bd5
+  metadata.gz: fed4e6689d48493416ebd409401df284fedaddb567d3558196b3ba3c253376dd1c4bea8db536fdb6ff8bbebe85512850d7d5c17605544ce26a09e814e7172eb5
+  data.tar.gz: b9d596e6445671254568b4bd3cc5b694a1011914ae67b1afc11aaa66a195f49b7371d001f9e10cc204a4c20e501cd8eb63092d63b9b392c701571a12843b5c91

data/README.md

@@ -43,21 +43,21 @@ Read SAM / BAM / CRAM - Sequence Alignment Map file
 ```ruby
 require 'htslib'
 
-bam = HTS::Bam.open("a.bam")
+bam = HTS::Bam.open("test/fixtures/moo.bam")
 
 bam.each do |r|
-  p name:  r.qname,
-    flag:  r.flag,
-    chr:   r.chrom,
-    pos:   r.start + 1,
-    mqual: r.mapping_quality,
-    cigar: r.cigar.to_s,
-    mchr:  r.mate_chrom,
-    mpos:  r.mate_start + 1,
-    isize: r.insert_size,
-    seq:   r.sequence,
-    qual:  r.base_qualities.map { |i| (i + 33).chr }.join,
-    tagMC: r.tag("MC")
+  pp name: r.qname,
+     flag: r.flag,
+     chrm: r.chrom,
+     strt: r.pos + 1,
+     mapq: r.mapq,
+     cigr: r.cigar.to_s,
+     mchr: r.mate_chrom,
+     mpos: r.mpos + 1,
+     isiz: r.isize,
+     seqs: r.seq,
+     qual: r.qual.map { |i| (i + 33).chr }.join,
+     MC:   r.aux("MC")
 end
 
 bam.close
@@ -75,9 +75,9 @@ bcf.each do |r|
     qual:   r.qual.round(2),
     ref:    r.ref,
     alt:    r.alt,
-    filter: r.filter
-  # info:   r.info
-  # format: r.format
+    filter: r.filter,
+    info:   r.info.to_h,
+    format: r.format.to_h
 end
 
 bcf.close

data/lib/hts/bam/aux.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module HTS
+  class Bam < Hts
+    class Aux
+      def initialize(record)
+        @record = record
+      end
+
+      def get(key, type = nil)
+        aux = LibHTS.bam_aux_get(@record.struct, key)
+        return nil if aux.null?
+
+        type ||= aux.read_string(1)
+
+        # A (character), B (general array),
+        # f (real number), H (hexadecimal array),
+        # i (integer), or Z (string).
+
+        case type
+        when "i", "I", "c", "C", "s", "S"
+          LibHTS.bam_aux2i(aux)
+        when "f", "d"
+          LibHTS.bam_aux2f(aux)
+        when "Z", "H"
+          LibHTS.bam_aux2Z(aux)
+        when "A" # char
+          LibHTS.bam_aux2A(aux).chr
+        else
+          raise NotImplementedError, "type: #{t}"
+        end
+      end
+
+      def [](key)
+        get(key)
+      end
+    end
+  end
+end

data/lib/hts/bam/cigar.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-# Based on hts-python
-# https://github.com/quinlan-lab/hts-python
-
 module HTS
   class Bam < Hts
     class Cigar

data/lib/hts/bam/flag.rb

@@ -27,70 +27,34 @@ module HTS
       # BAM_FDUP           = 1024
       # BAM_FSUPPLEMENTARY = 2048
 
-      # TODO: Enabling bitwise operations
-      # hts-nim
-      # proc `and`*(f: Flag, o: uint16): uint16 {. borrow, inline .}
-      # proc `and`*(f: Flag, o: Flag): uint16 {. borrow, inline .}
-      # proc `or`*(f: Flag, o: uint16): uint16 {. borrow .}
-      # proc `or`*(o: uint16, f: Flag): uint16 {. borrow .}
-      # proc `==`*(f: Flag, o: Flag): bool {. borrow, inline .}
-      # proc `==`*(f: Flag, o: uint16): bool {. borrow, inline .}
-      # proc `==`*(o: uint16, f: Flag): bool {. borrow, inline .}
+      # TODO: Enabling bitwise operations?
 
-      def paired?
-        has_flag? LibHTS::BAM_FPAIRED
-      end
-
-      def proper_pair?
-        has_flag? LibHTS::BAM_FPROPER_PAIR
-      end
-
-      def unmapped?
-        has_flag? LibHTS::BAM_FUNMAP
-      end
-
-      def mate_unmapped?
-        has_flag? LibHTS::BAM_FMUNMAP
-      end
-
-      def reverse?
-        has_flag? LibHTS::BAM_FREVERSE
-      end
-
-      def mate_reverse?
-        has_flag? LibHTS::BAM_FMREVERSE
-      end
-
-      def read1?
-        has_flag? LibHTS::BAM_FREAD1
-      end
-
-      def read2?
-        has_flag? LibHTS::BAM_FREAD2
-      end
-
-      def secondary?
-        has_flag? LibHTS::BAM_FSECONDARY
-      end
-
-      def qcfail?
-        has_flag? LibHTS::BAM_FQCFAIL
-      end
-
-      def dup?
-        has_flag? LibHTS::BAM_FDUP
-      end
+      TABLE = { paired?: LibHTS::BAM_FPAIRED,
+                proper_pair?: LibHTS::BAM_FPROPER_PAIR,
+                unmapped?: LibHTS::BAM_FUNMAP,
+                mate_unmapped?: LibHTS::BAM_FMUNMAP,
+                reverse?: LibHTS::BAM_FREVERSE,
+                mate_reverse?: LibHTS::BAM_FMREVERSE,
+                read1?: LibHTS::BAM_FREAD1,
+                read2?: LibHTS::BAM_FREAD2,
+                secondary?: LibHTS::BAM_FSECONDARY,
+                qcfail?: LibHTS::BAM_FQCFAIL,
+                duplicate?: LibHTS::BAM_FDUP,
+                supplementary?: LibHTS::BAM_FSUPPLEMENTARY }.freeze
 
-      def supplementary?
-        has_flag? LibHTS::BAM_FSUPPLEMENTARY
+      TABLE.each do |name, v|
+        define_method(name) do
+          has_flag?(v)
+        end
       end
 
-      def has_flag?(m)
-        (@value & m) != 0
+      def has_flag?(f)
+        (@value & f) != 0
       end
 
       def to_s
-        "0x#{format('%x', @value)}\t#{@value}\t#{LibHTS.bam_flag2str(@value)}"
+        LibHTS.bam_flag2str(@value)
+        # "0x#{format('%x', @value)}\t#{@value}\t#{LibHTS.bam_flag2str(@value)}"
       end
     end
   end

data/lib/hts/bam/header.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-# Based on hts-python
-# https://github.com/quinlan-lab/hts-python
-
 module HTS
   class Bam < Hts
     class Header
@@ -28,7 +25,7 @@ module HTS
         end
       end
 
-      def target_lengths
+      def target_len
         Array.new(target_count) do |i|
           LibHTS.sam_hdr_tid2len(@sam_hdr, i)
         end

data/lib/hts/bam/record.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
-# Based on hts-python
-# https://github.com/quinlan-lab/hts-python
+require_relative "flag"
+require_relative "cigar"
+require_relative "aux"
 
 module HTS
   class Bam < Hts
@@ -38,26 +39,49 @@ module HTS
         @bam1[:core][:tid]
       end
 
+      def tid=(tid)
+        @bam1[:core][:tid] = tid
+      end
+
       # returns the tid of the mate or -1 if not mapped.
-      def mate_tid
+      def mtid
         @bam1[:core][:mtid]
       end
 
+      def mtid=(mtid)
+        @bam1[:core][:mtid] = mtid
+      end
+
       # returns 0-based start position.
-      def start
+      def pos
         @bam1[:core][:pos]
       end
 
-      # returns end position of the read.
-      def stop
-        LibHTS.bam_endpos @bam1
+      def pos=(pos)
+        @bam1[:core][:pos] = pos
       end
 
       # returns 0-based mate position
-      def mate_start
+      def mpos
         @bam1[:core][:mpos]
       end
-      alias mate_pos mate_start
+
+      def mpos=(mpos)
+        @bam1[:core][:mpos] = mpos
+      end
+
+      def bin
+        @bam1[:core][:bin]
+      end
+
+      def bin=(bin)
+        @bam1[:core][:bin] = bin
+      end
+
+      # returns end position of the read.
+      def endpos
+        LibHTS.bam_endpos @bam1
+      end
 
       # returns the chromosome or '' if not mapped.
       def chrom
@@ -66,37 +90,44 @@ module HTS
         LibHTS.sam_hdr_tid2name(@header, tid)
       end
 
-      # returns the chromosome or '' if not mapped.
-      def contig
-        chrom
-      end
+      alias contig chrom
 
       # returns the chromosome of the mate or '' if not mapped.
       def mate_chrom
-        mtid = mate_tid
         return "" if mtid == -1
 
         LibHTS.sam_hdr_tid2name(@header, mtid)
       end
 
+      alias mate_contig mate_chrom
+
+      # Get strand information.
       def strand
         LibHTS.bam_is_rev(@bam1) ? "-" : "+"
       end
 
-      # def start=(v)
-      #   raise 'Not Implemented'
-      # end
-
       # insert size
       def insert_size
         @bam1[:core][:isize]
       end
 
+      alias isize insert_size
+
+      def insert_size=(isize)
+        @bam1[:core][:isize] = isize
+      end
+
+      alias isize= insert_size=
+
       # mapping quality
-      def mapping_quality
+      def mapq
         @bam1[:core][:qual]
       end
 
+      def mapq=(mapq)
+        @bam1[:core][:qual] = mapq
+      end
+
       # returns a `Cigar` object.
       def cigar
         Cigar.new(LibHTS.bam_get_cigar(@bam1), @bam1[:core][:n_cigar])
@@ -117,7 +148,7 @@ module HTS
       end
 
       # return the read sequence
-      def sequence
+      def seq
         r = LibHTS.bam_get_seq(@bam1)
         seq = String.new
         (@bam1[:core][:l_qseq]).times do |i|
@@ -125,64 +156,77 @@ module HTS
         end
         seq
       end
+      alias sequence seq
+
+      def len
+        @bam1[:core][:l_qseq]
+      end
 
       # return only the base of the requested index "i" of the query sequence.
-      def base_at(n)
+      def base(n)
         n += @bam1[:core][:l_qseq] if n < 0
-        return "." if (n >= @bam1[:core][:l_qseq]) || (n < 0) # eg. base_at(-1000)
+        return "." if (n >= @bam1[:core][:l_qseq]) || (n < 0) # eg. base(-1000)
 
         r = LibHTS.bam_get_seq(@bam1)
         SEQ_NT16_STR[LibHTS.bam_seqi(r, n)]
       end
 
       # return the base qualities
-      def base_qualities
+      def qual
         q_ptr = LibHTS.bam_get_qual(@bam1)
         q_ptr.read_array_of_uint8(@bam1[:core][:l_qseq])
       end
 
       # return only the base quality of the requested index "i" of the query sequence.
-      def base_quality_at(n)
+      def base_qual(n)
         n += @bam1[:core][:l_qseq] if n < 0
-        return 0 if (n >= @bam1[:core][:l_qseq]) || (n < 0) # eg. base_quality_at(-1000)
+        return 0 if (n >= @bam1[:core][:l_qseq]) || (n < 0) # eg. base_qual(-1000)
 
         q_ptr = LibHTS.bam_get_qual(@bam1)
         q_ptr.get_uint8(n)
       end
 
-      def flag_str
-        LibHTS.bam_flag2str(@bam1[:core][:flag])
-      end
-
       # returns a `Flag` object.
       def flag
         Flag.new(@bam1[:core][:flag])
       end
 
-      def tag(str)
-        aux = LibHTS.bam_aux_get(@bam1, str)
-        return nil if aux.null?
+      def flag=(flag)
+        case flag
+        when Integer
+          @bam1[:core][:flag] = flag
+        when Flag
+          @bam1[:core][:flag] = flag.value
+        else
+          raise "Invalid flag type: #{flag.class}"
+        end
+      end
+
+      # retruns the auxillary fields.
+      def aux(key = nil)
+        aux = Aux.new(self)
+        if key
+          aux.get(key)
+        else
+          aux
+        end
+      end
+
+      # TODO: add a method to get the auxillary fields as a hash.
 
-        t = aux.read_string(1)
+      # TODO: add a method to set the auxillary fields.
 
-        # A (character), B (general array),
-        # f (real number), H (hexadecimal array),
-        # i (integer), or Z (string).
+      # TODO: add a method to remove the auxillary fields.
 
-        case t
-        when "i", "I", "c", "C", "s", "S"
-          LibHTS.bam_aux2i(aux)
-        when "f", "d"
-          LibHTS.bam_aux2f(aux)
-        when "Z", "H"
-          LibHTS.bam_aux2Z(aux)
-        when "A" # char
-          LibHTS.bam_aux2A(aux).chr
+      # TODO: add a method to set variable length data (qname, cigar, seq, qual).
+
+      # Calling flag is delegated to the Flag object.
+      Flag::TABLE.each_key do |m|
+        define_method(m) do
+          flag.send(m)
         end
       end
 
-      # def tags; end
-
       def to_s
         kstr = LibHTS::KString.new
         raise "Failed to format bam record" if LibHTS.sam_format1(@header.struct, @bam1, kstr) == -1

data/lib/hts/bam.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-# Based on hts-python
-# https://github.com/quinlan-lab/hts-python
-
 require_relative "../htslib"
 
 require_relative "hts"
@@ -15,7 +12,7 @@ module HTS
   class Bam
     include Enumerable
 
-    attr_reader :file_name, :index_path, :mode, :header
+    attr_reader :file_name, :index_name, :mode, :header
 
     def self.open(*args, **kw)
       file = new(*args, **kw) # do not yield
@@ -38,9 +35,10 @@ module HTS
 
       # NOTE: Do not check for the existence of local files, since file_names may be remote URIs.
 
-      @file_name = file_name
-      @mode      = mode
-      @hts_file  = LibHTS.hts_open(@file_name, mode)
+      @file_name  = file_name
+      @index_name = index
+      @mode       = mode
+      @hts_file   = LibHTS.hts_open(@file_name, mode)
 
       raise Errno::ENOENT, "Failed to open #{@file_name}" if @hts_file.null?
 
@@ -66,11 +64,10 @@ module HTS
     end
 
     def create_index(index_name = nil)
+      warn "Create index for #{@file_name} to #{index_name}"
       if index
-        warn "Create index for #{@file_name} to #{index_name}"
         LibHTS.sam_index_build2(@file_name, index_name, -1)
       else
-        warn "Create index for #{@file_name} to #{index_name}"
         LibHTS.sam_index_build(@file_name, -1)
       end
     end
@@ -91,21 +88,20 @@ module HTS
     def close
       LibHTS.hts_idx_destroy(@idx) if @idx&.null?
       @idx = nil
-      LibHTS.hts_close(@hts_file)
-      @hts_file = nil
-    end
-
-    def closed?
-      @hts_file.nil? || @hts_file.null?
+      super
     end
 
     def write_header(header)
+      raise IOError, "closed stream" if closed?
+
       @header = header.dup
       LibHTS.hts_set_fai_filename(@hts_file, @file_name)
       LibHTS.sam_hdr_write(@hts_file, header)
     end
 
     def write(aln)
+      raise IOError, "closed stream" if closed?
+
       aln_dup = aln.dup
       LibHTS.sam_write1(@hts_file, header, aln_dup) > 0 || raise
     end
@@ -114,6 +110,7 @@ module HTS
     # Generate a new Record object each time.
     # Slower than each.
     def each_copy
+      raise IOError, "closed stream" if closed?
       return to_enum(__method__) unless block_given?
 
       while LibHTS.sam_read1(@hts_file, header, bam1 = LibHTS.bam_init1) != -1
@@ -127,6 +124,7 @@ module HTS
     # Record object is reused.
     # Faster than each_copy.
     def each
+      raise IOError, "closed stream" if closed?
       # Each does not always start at the beginning of the file.
       # This is the common behavior of IO objects in Ruby.
       # This may change in the future.
@@ -140,6 +138,7 @@ module HTS
 
     # query [WIP]
     def query(region)
+      raise IOError, "closed stream" if closed?
       raise "Index file is required to call the query method." unless index_loaded?
 
       qiter = LibHTS.sam_itr_querys(@idx, header, region)

data/lib/hts/bcf/format.rb

@@ -1,9 +1,5 @@
 # frozen_string_literal: true
 
-# https://github.com/brentp/hts-nim/blob/master/src/hts/vcf.nim
-# This is a port from Nim.
-# TODO: Make it more like Ruby.
-
 module HTS
   class Bcf < Hts
     class Format
@@ -32,6 +28,10 @@ module HTS
         get(key, :string)
       end
 
+      def [](key)
+        get(key)
+      end
+
       def get(key, type = nil)
         n = FFI::MemoryPointer.new(:int)
         p1 = @p1
@@ -45,7 +45,15 @@ module HTS
           p1.read_pointer
         end
 
-        case type.to_sym
+        # The GT FORMAT field is special in that it is marked as a string in the header,
+        # but it is actually encoded as an integer.
+        if key == "GT"
+          type = :int
+        elsif type.nil?
+          type = ht_type_to_sym(get_fmt_type(key))
+        end
+
+        case type&.to_sym
         when :int, :int32
           format_values.call(LibHTS::BCF_HT_INT)
                        .read_array_of_int32(n.read_int)
@@ -53,22 +61,85 @@ module HTS
           format_values.call(LibHTS::BCF_HT_REAL)
                        .read_array_of_float(n.read_int)
         when :flag
-          raise NotImplementedError, "Flag type not implemented yet."
+          raise NotImplementedError, "Flag type not implemented yet. " \
+          "Please file an issue on GitHub."
           # format_values.call(LibHTS::BCF_HT_FLAG)
           #              .read_int == 1
         when :string, :str
-          raise NotImplementedError, "String type not implemented yet."
+          raise NotImplementedError, "String type not implemented yet. " \
+          "Please file an issue on GitHub."
           # format_values.call(LibHTS::BCF_HT_STR)
           #              .read_string
         end
       end
 
-      def set; end
+      def fields
+        ids.map do |id|
+          name = LibHTS.bcf_hdr_int2id(@record.header.struct, LibHTS::BCF_DT_ID, id)
+          num  = LibHTS.bcf_hdr_id2number(@record.header.struct, LibHTS::BCF_HL_FMT, id)
+          type = LibHTS.bcf_hdr_id2type(@record.header.struct, LibHTS::BCF_HL_FMT, id)
+          {
+            name: name,
+            n: num,
+            type: ht_type_to_sym(type),
+            id: id
+          }
+        end
+      end
 
-      # def fields # iterator
-      # end
+      def length
+        @record.struct[:n_fmt]
+      end
+
+      def size
+        length
+      end
+
+      def to_h
+        ret = {}
+        ids.each do |id|
+          name = LibHTS.bcf_hdr_int2id(@record.header.struct, LibHTS::BCF_DT_ID, id)
+          ret[name] = get(name)
+        end
+        ret
+      end
 
-      def genotypes; end
+      # def genotypes; end
+
+      private
+
+      def fmt_ptr
+        @record.struct[:d][:fmt].to_ptr
+      end
+
+      def ids
+        fmt_ptr.read_array_of_struct(LibHTS::BcfFmt, length).map do |fmt|
+          fmt[:id]
+        end
+      end
+
+      def get_fmt_type(qname)
+        @record.struct[:n_fmt].times do |i|
+          fmt = LibHTS::BcfFmt.new(@record.struct[:d][:fmt] + i * LibHTS::BcfFmt.size)
+          id = fmt[:id]
+          name = LibHTS.bcf_hdr_int2id(@record.header.struct, LibHTS::BCF_DT_ID, id)
+          if name == qname
+            type = LibHTS.bcf_hdr_id2type(@record.header.struct, LibHTS::BCF_HL_FMT, id)
+            return type
+          end
+        end
+        nil
+      end
+
+      def ht_type_to_sym(t)
+        case t
+        when LibHTS::BCF_HT_FLAG then :flag
+        when LibHTS::BCF_HT_INT then :int
+        when LibHTS::BCF_HT_REAL then :float
+        when LibHTS::BCF_HT_STR then :string
+        when LibHTS::BCF_HT_LONG then :float
+        end
+      end
     end
   end
 end