rgfa 1.2.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2f8b7edb6df7ada4a6f53db674a3b306e00e2861
+  data.tar.gz: 87d224980a807f6b8e98917b845d48a12ec11e4b
+SHA512:
+  metadata.gz: c38a9ef751a5220dd59991a4b0788d8860d66ead6880c03de53ab047970cb3ad4719b23c4dd1b7b1d262dfe29cc84b82e105d10e938e83231ad3969efdf86edd
+  data.tar.gz: b87e1dcd4f7ddccb77bdb03edad2a52ae23e8b5c9f22629f4aa57206c75306b7e7f813e5154c76245de14113d532e983795957721bd0ecce9d772a7e95ee6259

data/bin/gfadiff.rb

@@ -0,0 +1,420 @@
+#!/usr/bin/env ruby
+
+require "rgfa"
+
+rt = []
+all_rt = %W[-h -s -l -c -p]
+all_rt.each do |rtopt|
+  rt << ARGV.delete(rtopt)
+end
+rt.compact!
+rt = all_rt if rt.empty?
+
+out_identical = ARGV.delete("-i")
+
+out_script = ARGV.delete("-script")
+
+if ARGV.size != 2
+  STDERR.puts "Compare two RGFA files"
+  STDERR.puts
+  STDERR.puts "Usage: #$0 [-h] [-s] [-l] [-c] [-p] [-i] [-script] <gfa1> <gfa2>"
+  STDERR.puts
+  STDERR.puts "If a combination of -h,-s,-l,-c and/or -p is specified, then"
+  STDERR.puts "only record of the specified type [h=headers, s=segments, "
+  STDERR.puts "l=links, c=containments, p=paths] are compared. "
+  STDERR.puts "(default: -h -s -l -c -p)"
+  STDERR.puts
+  STDERR.puts "Other options:"
+  STDERR.puts "  -i: output msg if identical"
+  STDERR.puts "  -script: create ruby script to transform gfa1 in gfa2"
+  exit 1
+end
+
+if out_script
+  puts "#!/usr/bin/env ruby"
+  puts
+  puts "#"
+  puts "# This script was automatically generated using gfadiff.rb"
+  puts "#"
+  puts "# Purpose: edit gfa1 into gfa2"
+  puts "#"
+  puts "# gfa1: #{ARGV[0]}"
+  puts "# gfa2: #{ARGV[1]}"
+  puts "#"
+  puts
+  puts "require \"rgfa\""
+  puts
+  puts "gfa = RGFA.from_file(\"#{ARGV[0]}\")"
+  puts
+end
+
+gfa1 = RGFA.new
+gfa1.turn_off_validations
+gfa1.read_file(ARGV[0])
+gfa2 = RGFA.new
+gfa2.turn_off_validations
+gfa2.read_file(ARGV[1])
+
+if rt.include?("-h")
+  h1 = gfa1.header
+  h2 = gfa2.header
+  if h1 == h2
+    if out_identical
+      puts "# Header values are identical"
+    elsif out_script
+      puts "# Headers"
+      puts "# ... are identical"
+      puts
+    end
+  else
+    if out_script
+      puts "# Headers"
+      puts
+    end
+    (h1.optional_fieldnames - h2.optional_fieldnames).each do |k|
+      if out_script
+        puts "gfa.header.delete_field(#{k.inspect})"
+      else
+        v = h1.get(k)
+        if v.kind_of?(RGFA::FieldArray)
+          t = v.datatype
+          v.each do |elem|
+            elem = elem.to_gfa_field(datatype: t)
+            puts "<\t[headers/exclusive/multivalue/#{k}]\t#{elem}"
+          end
+        else
+          v = h1.field_to_s(k, optfield: true)
+          puts "M\t[headers/exclusive]\t#{k.inspect}\t#{v}"
+        end
+      end
+    end
+    (h2.optional_fieldnames - h1.optional_fieldnames).each do |k|
+      v = h2.get(k)
+      if out_script
+        t = h2.get_datatype(k)
+        puts "gfa.header.set_datatype(#{k.inspect}, #{t.inspect})"
+        if v.kind_of?(RGFA::FieldArray)
+          t = v.datatype
+          v.each do |elem|
+            puts "gfa.header.add(#{k.inspect}, #{elem.inspect}, "+
+                 "#{t.inspect})"
+          end
+        else
+          puts "gfa.header.#{k}=#{v.inspect}"
+        end
+      else
+        if v.kind_of?(RGFA::FieldArray)
+          t = v.datatype
+          v.each do |elem|
+            elem = elem.to_gfa_field(datatype: t)
+            puts ">\t[headers/exclusive/multivalue/#{k}]\t#{elem}"
+          end
+        else
+          v = h2.field_to_s(k, optfield: true)
+          puts ">\t[headers/exclusive]\t#{k.inspect}\t#{v}"
+        end
+      end
+    end
+    (h1.optional_fieldnames & h2.optional_fieldnames).each do |k|
+      v1 = h1.get(k)
+      v2 = h2.get(k)
+      v1a = v1.kind_of?(RGFA::FieldArray) ? v1.sort : [v1]
+      v2a = v2.kind_of?(RGFA::FieldArray) ? v2.sort : [v2]
+      t1 = v1.kind_of?(RGFA::FieldArray) ? v1.datatype : h1.get_datatype(k)
+      t2 = v2.kind_of?(RGFA::FieldArray) ? v2.datatype : h2.get_datatype(k)
+      m1 = v1.kind_of?(RGFA::FieldArray) ? "multivalue/" : ""
+      m2 = v2.kind_of?(RGFA::FieldArray) ? "multivalue/" : ""
+      if out_script
+        if t1 != t2 or v1a != v2a
+          puts "gfa.header.delete(#{k.inspect})"
+          v2a.each do |v2|
+            v2 = v2.to_gfa_field(datatype: t2)
+            puts "gfa.header.add(#{k.inspect}, #{v2.inspect}, "+
+                 "#{t2.inspect})"
+          end
+        end
+      else
+        if t1 != t2
+          v1a.each do |v1|
+            v1 = v1.to_gfa_field(datatype: t1)
+            puts "<\t[headers/typediff/#{m1}#{k}#{}]\t#{v1}"
+          end
+          v2a.each do |v2|
+            v2 = v2.to_gfa_field(datatype: t2)
+            puts ">\t[headers/typediff/#{m2}#{k}]\t#{v2}"
+          end
+        else
+          (v1a-v2a).each do |v1|
+            v1 = v1.to_gfa_field(datatype: t1)
+            puts "<\t[headers/valuediff/#{m1}#{k}]\t#{v1}"
+          end
+          (v2a-v1a).each do |v2|
+            v2 = v2.to_gfa_field(datatype: t2)
+            puts ">\t[headers/valuediff/#{m2}#{k}]\t#{v2}"
+          end
+        end
+      end
+    end
+    if out_script
+      puts
+    end
+  end
+end
+
+def diff_segments_or_paths(gfa1,gfa2,rt,out_script,out_identical)
+  rts = rt + "s"
+  rtsU = rts[0].upcase + rts[1..-1]
+  s1names = gfa1.send("#{rt}_names").sort
+  s2names = gfa2.send("#{rt}_names").sort
+  difffound = false
+  if out_script
+    puts "# #{rtsU}"
+    puts
+  end
+  (s1names - s2names).each do |sn|
+    difffound = true
+    segstr = gfa1.send(rt,sn).to_s
+    if out_script
+      puts "gfa.rm(#{sn.inspect})"
+    else
+      puts "<\t[#{rts}/exclusive]\t#{segstr}"
+    end
+  end
+  (s2names - s1names).each do |sn|
+    difffound = true
+    segstr = gfa2.send(rt,sn).to_s
+    if out_script
+      puts "gfa << #{segstr.inspect}"
+    else
+      puts ">\t[#{rts}/exclusive]\t#{segstr}"
+    end
+  end
+  (s1names & s2names).each do |sn|
+    s1 = gfa1.send(rt,sn)
+    s2 = gfa2.send(rt,sn)
+    s1.required_fieldnames.each do |fn|
+      v1 = s1.field_to_s(fn)
+      v2 = s2.field_to_s(fn)
+      if v1 != v2
+        difffound = true
+        if out_script
+          puts "gfa.#{rt}(#{sn.inspect}).#{fn}=#{v2.inspect}"
+        else
+          puts "<\t[#{rts}/reqfields/valuediff/#{sn}]\t#{v1}"
+          puts ">\t[#{rts}/reqfields/valuediff/#{sn}]\t#{v2}"
+        end
+      end
+    end
+    s1f = s1.optional_fieldnames
+    s2f = s2.optional_fieldnames
+    (s1f - s2f).each do |fn|
+      difffound = true
+      if out_script
+        puts "gfa.#{rt}(#{sn.inspect}).delete_field(#{fn.inspect})"
+      else
+        v = s1.field_to_s(fn, optfield: true)
+        puts "<\t[#{rts}/optfields/exclusive/#{sn}]\t#{v}"
+      end
+    end
+    (s2f - s1f).each do |fn|
+      difffound = true
+      if out_script
+        v = s2.get(fn)
+        t = s2.get_datatype(fn)
+        puts "gfa.#{rt}(#{sn.inspect}).set_datatype(#{fn.inspect},#{t})"
+        puts "gfa.#{rt}(#{sn.inspect}).#{fn}=#{v.inspect}"
+      else
+        v = s2.field_to_s(fn, optfield: true)
+        puts ">\t[#{rts}/optfields/exclusive/#{sn}]\t#{v}"
+      end
+    end
+    (s1f & s2f).each do |fn|
+      v1 = s1.field_to_s(fn, optfield: true)
+      v2 = s2.field_to_s(fn, optfield: true)
+      if v1 != v2
+        difffound = true
+        if out_script
+          v = s2.get(fn)
+          t = s2.get_datatype(fn)
+          puts "gfa.#{rt}(#{sn.inspect}).set_datatype(#{fn.inspect},#{t})"
+          puts "gfa.#{rt}(#{sn.inspect}).#{fn}=#{v.inspect}"
+        else
+          puts "<\t[#{rts}/optfields/valuediff/#{sn}]\t#{v1}"
+          puts ">\t[#{rts}/optfields/valuediff/#{sn}]\t#{v2}"
+        end
+      end
+    end
+  end
+  if !difffound
+    if out_script
+      puts "# ... are identical"
+    elsif out_identical
+      puts "# #{rtsU} are identical"
+    end
+  end
+  puts if out_script
+end
+
+if rt.include?("-s")
+  diff_segments_or_paths(gfa1,gfa2, "segment",out_script,out_identical)
+end
+
+# TODO: diff of single optfields
+if rt.include?("-l")
+  difffound = false
+  s1names = gfa1.segment_names.sort
+  s2names = gfa2.segment_names.sort
+  if out_script
+    puts "# Links"
+    puts
+  end
+  difflinks1 = []
+  (s1names - s2names).each do |sn|
+    difffound = true
+    [:B, :E].each {|et| difflinks1 += gfa1.links_of([sn, et])}
+  end
+  difflinks1.uniq.each do |l|
+    if !out_script
+      puts "<\t[links/exclusive_segments]\t#{l.to_s}"
+    end
+  end
+  difflinks2 = []
+  (s2names - s1names).each do |sn|
+    difffound = true
+    [:B, :E].each {|et| difflinks2 += gfa2.links_of([sn, et])}
+  end
+  difflinks2.uniq.each do |l|
+    if out_script
+      puts "gfa << #{l.to_s.inspect}"
+    else
+      puts ">\t[links/exclusive_segments]\t#{l.to_s}"
+    end
+  end
+  difflinks1b = []
+  difflinks2b = []
+  (s1names & s2names).each do |sn|
+    [:B, :E].each do |et|
+      l1 = gfa1.links_of([sn, et])
+      l2 = gfa2.links_of([sn, et])
+      d1 = l1 - l2
+      d2 = l2 - l1
+      if !d1.empty?
+        difffound = true
+        difflinks1b += d1
+      end
+      if !d2.empty?
+        difffound = true
+        difflinks2b += d2
+      end
+    end
+  end
+  (difflinks1b-difflinks1).uniq.each do |l|
+    if out_script
+      puts "gfa.rm(gfa.link_from_to(#{l.from.to_sym.inspect}, "+
+                                   "#{l.from_orient.inspect}, "+
+                                   "#{l.to.to_sym.inspect}, "+
+                                   "#{l.to_orient.inspect}, "+
+                                   "#{l.overlap.to_s.inspect}.to_cigar))"
+    else
+      puts "<\t[links/different]\t#{l.to_s}"
+    end
+  end
+  (difflinks2b-difflinks2).uniq.each do |l|
+    if out_script
+      puts "gfa << #{l.to_s.inspect}"
+    else
+      puts ">\t[links/different]\t#{l.to_s}"
+    end
+  end
+  if !difffound
+    if out_script
+      puts "# ... are identical"
+    elsif out_identical
+      puts "# Links are identical"
+    end
+  end
+  puts if out_script
+end
+
+# TODO: this code is similar to -l; make generic and merge
+if rt.include?("-c")
+  difffound = false
+  s1names = gfa1.segment_names.sort
+  s2names = gfa2.segment_names.sort
+  cexcl1 = []
+  (s1names - s2names).each do |sn|
+    difffound = true
+    cexcl1 += gfa1.contained_in(sn)
+    cexcl1 += gfa1.containing(sn)
+  end
+  cexcl1.uniq.each do |c|
+    if !out_script
+      puts "<\t[contaiments/exclusive_segments]\t#{c.to_s}"
+    end
+  end
+  cexcl2 = []
+  (s2names - s1names).each do |sn|
+    difffound = true
+    cexcl2 += gfa2.contained_in(sn)
+    cexcl2 += gfa2.containing(sn)
+  end
+  cexcl2.uniq.each do |c|
+    if out_script
+      puts "gfa << #{c.to_s.inspect}"
+    else
+      puts ">\t[contaiments/exclusive_segments]\t#{c.to_s}"
+    end
+  end
+  cdiff1 = []
+  cdiff2 = []
+  (s1names & s2names).each do |sn|
+    c1 = gfa1.contained_in(sn)
+    c2 = gfa2.contained_in(sn)
+    c1 += gfa1.containing(sn)
+    c2 += gfa2.containing(sn)
+    d1 = c1 - c2
+    d2 = c2 - c1
+    if !d1.empty?
+      difffound = true
+      cdiff1 += d1
+    end
+    if !d2.empty?
+      difffound = true
+      cdiff2 += d2
+    end
+  end
+  (cdiff1-cexcl1).uniq.each do |l|
+    if out_script
+      # TODO: handle multiple containments for a segments pair
+      puts "gfa.rm(gfa.containment(#{l.from.to_sym.inspect}, "+
+                                  "#{l.to.to_sym.inspect}))"
+    else
+      puts "<\t[containments/different]\t#{l.to_s}"
+    end
+  end
+  (cdiff2-cexcl2).uniq.each do |l|
+    if out_script
+      puts "gfa << #{l.to_s.inspect}"
+    else
+      puts ">\t[containments/different]\t#{l.to_s}"
+    end
+  end
+  if !difffound
+    if out_script
+      puts "# ... are identical"
+    elsif out_identical
+      puts "# Containments are identical"
+    end
+  end
+  puts if out_script
+end
+
+if rt.include?("-p")
+  diff_segments_or_paths(gfa1,gfa2,"path",out_script,out_identical)
+end
+
+if out_script
+  puts
+  puts "# Output graph"
+  puts "puts gfa"
+end

data/bin/rgfa-findcrisprs.rb

@@ -0,0 +1,208 @@
+#!/usr/bin/env ruby
+
+require "rgfatools"
+
+# crisprs have a structure ARU1RU..RUnRB where |U|~|R| in [24..50]
+
+$debugmode = false
+$spacersonly = false
+
+class RGFA
+
+  def find_crisprs(minrepeats=3,minlen=24,maxlen=50)
+    ls = {}
+    segment_names.each do |sn|
+      s = segment(sn)
+      s.cn = (s.coverage(unit_length: @default[:unit_length],
+                         count_tag: @default[:count_tag])/2).round
+    end
+    output_segment_infos if $debugmode
+    maxvisits_global = {:B => {}, :E => {}}
+    segment_names.each do |sn|
+      s = segment(sn)
+      next if s.length < minlen or s.length > maxlen
+      next if s.cn < minrepeats
+      circles = {}
+      linear = {}
+      maxvisits = {}
+      [:B, :E].each do |rt|
+        maxvisits[rt] = maxvisits_global[rt].dup
+        maxvisits[rt][sn] ||= s.cn
+        circles[rt] = []
+        linear[rt] = []
+        segment_end = [s, rt].to_segment_end
+        links_of(segment_end).each do |l|
+          search_circle(segment_end.invert_end_type,
+                        segment_end,
+                        l,
+                        maxvisits[rt],0,
+                        minlen,
+                        maxlen*2+s.length,
+                        [segment_end],
+                        circles[rt],
+                        linear[rt])
+        end
+        if maxvisits[rt][sn.to_sym] > 0
+          multi = {:l => [], :c => []}
+          [[linear[rt],:l], [circles[rt],:c]].each do |paths, pt|
+            paths.each do |c|
+              min_mv = s.cn
+              upto = (pt == :l ? -1 : -2)
+              c[0..upto].each do |csn, et|
+                mv = maxvisits[rt][csn.to_sym]
+                if mv < min_mv
+                  min_mv = mv
+                end
+              end
+              if min_mv > 0
+                min_mv.times { multi[pt] << c.dup }
+                c[0..upto].each do |csn, et|
+                  maxvisits[rt][csn.to_sym] -= min_mv
+                end
+              end
+            end
+          end
+          circles[rt] += multi[:c]
+          linear[rt] += multi[:l]
+        end
+      end
+      n_paths = (circles[:E].size+circles[:B].size+
+                 linear[:E].size+linear[:B].size)
+      if (circles[:E].size - circles[:B].size).abs > 1
+        next
+      end
+      if (linear[:E].size - linear[:B].size).abs > 0
+        next
+      end
+      if linear[:E].size != 1
+        next
+      end
+      merged_circles = []
+      circles[:E].each {|c|merged_circles << merge_crisprs_path(c,s,:E)}
+      before = merge_crisprs_path(linear[:B].first,s,:B)
+      after = merge_crisprs_path(linear[:E].first,s,:E)
+      next if merged_circles.size < minrepeats
+      maxvisits_global = maxvisits
+      instances = 1
+      possible_instances = 0
+      merged_circles.each do |seq|
+        if seq.length > s.length + minlen
+          possible_instances += 1
+        end
+        instances += 1
+      end
+      if $spacersonly
+        puts merged_circles.sort.map(&:upcase)
+      else
+        puts "CRISP signature found in segment #{s.name}"
+        puts
+        puts "  Before: sequence = ...#{before[-50..-1]}"
+        puts
+        if possible_instances > 0
+          instances = "#{instances}..#{instances+possible_instances}"
+        end
+        puts "  Repeat: instances = #{instances}; "+
+        "length = #{s.length};\t"+
+        "sequence = #{s.sequence}"
+        puts
+        puts "  Spacers:"
+        asterisk = false
+        merged_circles.each_with_index do |seq, i|
+          if seq.length > s.length + minlen
+            str = "=#{s.length}+2*#{(seq.length.to_f - s.length)/2}"
+            asterisk = true
+            this_asterisk = true
+          else
+            str = ""
+            this_asterisk = false
+          end
+          puts "    (#{i+1}#{this_asterisk ? "*" : ""})\t"+
+            "length = #{seq.length}#{str};\tsequence = #{seq}"
+        end
+        if asterisk
+          puts
+          puts "    * = possibly containing inexact repeat instance"
+        end
+        puts
+        puts "After: sequence = #{after[0..49]}..."
+      end
+    end
+  end
+
+  private
+
+  def output_segment_infos
+    segment_names.each do |sn|
+      s = segment(sn)
+      puts "#{s.name}\t#{s.cn}\t"+
+        "#{neighbours([s.name,:B]).map{|nb|segment(nb.segment).cn}.inject(:+)}\t"+
+        "#{neighbours([s.name,:E]).map{|nb|segment(nb.segment).cn}.inject(:+)}\t"+
+        "#{links_of([s.name,:B]).size}\t"+
+        "#{links_of([s.name,:E]).size}\t"+
+        "#{s.KC}\t#{s.length}"
+    end
+  end
+
+  def merge_crisprs_path(segpath, repeat, repeat_end)
+    merged = create_merged_segment(segpath, merged_name: :short,
+                                 disable_tracking: true)[0]
+    sequence = merged.sequence[repeat.
+                                 sequence.length..-(1+repeat.sequence.length)]
+    sequence = sequence.rc if repeat_end == :B
+    return sequence
+  end
+
+  def search_circle(goal, from, l, maxvisits, dist, mindist,
+                    maxdist, path, circles, linear)
+    dest = l.other_end(from)
+    dest.segment = segment(dest.segment)
+    maxvisits[dest.name] ||= dest.segment.cn
+    se = dest.invert_end_type
+    if dest == goal
+      return if dist < mindist
+      new_path = path.dup
+      new_path << se
+      new_path[0..-2].each {|x| maxvisits[x.name] -= 1}
+      circles << new_path
+      return
+    end
+    return if maxvisits[dest.name] == 0
+    return if path.any?{|x|x.name==dest.name}
+    new_path = path.dup
+    new_path << se
+    dist += dest.segment.length - l.overlap.first.len
+    if dist > maxdist
+      new_path = path.dup
+      new_path << se
+      new_path[0..-1].each {|x| maxvisits[x.name] -= 1}
+      linear << new_path
+      return
+    end
+    ls = links_of(se)
+    if ls.size == 0
+      new_path[0..-1].each {|x| maxvisits[x.name] -= 1}
+      linear << new_path
+      return
+    end
+    ls.each do |next_l|
+      next_dest = segment(next_l.other_end(se).segment)
+      maxvisits[next_dest.name] ||= next_dest.cn
+      next if maxvisits[next_dest.name] == 0
+      search_circle(goal,se,next_l,maxvisits,dist,mindist,maxdist,new_path,
+                    circles,linear)
+    end
+    return
+  end
+
+end
+
+if (ARGV.size == 0)
+  STDERR.puts "Usage: #$0 <gfa>"
+  exit 1
+end
+gfa = RGFA.from_file(ARGV[0])
+gfa.set_default_count_tag(:KC)
+gfa.header.ks ||= gfa.segments[0].length + 1
+gfa.set_count_unit_length(gfa.header.ks-1)
+gfa.find_crisprs
+