gfa 0.4.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 97e6400338884b4ceb1161778c26c5d6de6ee71616be1b5caae6aa0691d88395
-  data.tar.gz: 2fe8103598246724d98e3ceeecce92b5564f45bf029bf034978277cde59b4caa
+  metadata.gz: dc98fa1d3479be3fee554dab64876d6cd42795aec08a6b60be6ccb148c57c679
+  data.tar.gz: 28ef77ca42b374e58c983f474d44801060dadb2df912230e431cf40ee8f1386c
 SHA512:
-  metadata.gz: 3beac70ac4c3d4e46bd01399351fbc5e5ffcdaac5bd2a653b7f17c8f29df5c13e48a11575c42fa0ec78cba62485528148687614e9373ac6cc5dd773f97cd67a6
-  data.tar.gz: c488a4b26604ffc95228d5aa454399b4da8facecb9a90c2579be3c36446637bc60b89578c5a5443047ac020c4c9fb9b980fd3943fdb56e7993ebfcc7c4e60876
+  metadata.gz: 1a7226dbe5813cc9e7b0cde0e756b0b41395d45e690fd3df0e6ad266f51a209d55d72fdaeaab5aaebd3fec7ce033b54bb04510903cc3eadef230bd30485f037e
+  data.tar.gz: 32f081a9cf35219f05cb21654011a32a1645f13cbf1d7dda320ebef0b7d893523943cd71f8c9f8a310f1021b6adfaa99b1f863d498be1bbb77bf0a5e04779efd

data/bin/gfa-greedy-modules

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+
+# @package MiGA
+# @license Artistic-2.0
+
+$LOAD_PATH.push File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.push File.expand_path('../../lib', File.realpath(__FILE__))
+
+require 'gfa'
+
+input, base, min_len, threads = ARGV
+
+unless base
+  $stderr.puts <<~HELP
+    Split a GFA into multiple independent GFA files that have no links between
+    them by greedily identifying all individual modules in the graph
+
+    gfa-greedy-modules <input> <base> [<min_len> [<threads>]]
+
+    <input>      Input GFA file to read
+    <base>       Prefix of the output GFA files to write
+    <min_len>    Minimum length (in bp) to report a module
+                 By default: 0 (all modules are reported)
+    <threads>    If passed, parallelize process with these many threads
+  HELP
+  exit(1)
+end
+
+$stderr.puts "Loading GFA: #{input}"
+gfa = GFA.load_parallel(input, (threads || 1).to_i)
+
+$stderr.puts 'Splitting graph into modules'
+gfas = gfa.split_modules
+
+min_len = min_len.to_i
+if min_len > 0
+  $stderr.puts 'Filtering out small modules'
+  gfas.select! { |gfa| gfa.total_length > min_len }
+end
+
+if gfas.empty?
+  $stderr.puts "No modules found"
+else
+  $stderr.puts "Saving #{gfas.size} GFA files: #{base}.*"
+  int_len = Math.log10(gfas.size).ceil
+  gfas.each_with_index do |gfa, k|
+    gfa.save("%s.%0#{int_len}i.gfa" % [base, k])
+  end
+end
+

data/bin/gfa-mean-depth

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+
+# @package MiGA
+# @license Artistic-2.0
+
+$LOAD_PATH.push File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.push File.expand_path('../../lib', File.realpath(__FILE__))
+
+require 'gfa'
+
+input, threads = ARGV
+
+unless input
+  $stderr.puts <<~HELP
+    Calculate the average sequencing depth of all segments in the GFA
+    weighted by the segment lengths
+
+    gfa-mean-depth <input> [<threads>]
+
+    <input>      Input GFA file to read
+    <threads>    If passed, parallelize process with these many threads
+  HELP
+  exit(1)
+end
+
+$stderr.puts "Loading GFA: #{input}"
+gfa = GFA.load_parallel(input, (threads || 1).to_i)
+
+$stderr.puts 'Calculating average depth'
+n = gfa.total_length
+avg =
+  gfa.segments.set.map do |segment|
+    raise "Some segments are missing depth data" unless segment.DP
+    segment.DP.value * segment.length / n
+  end.inject(:+)
+puts avg
+

data/bin/gfa-merge

@@ -0,0 +1,34 @@
+#!/usr/bin/env ruby
+
+# @package MiGA
+# @license Artistic-2.0
+
+$LOAD_PATH.push File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.push File.expand_path('../../lib', File.realpath(__FILE__))
+
+require 'gfa'
+
+output = ARGV.shift
+input  = ARGV
+
+if input.empty?
+  $stderr.puts <<~HELP
+    Combine several GFAs into a single GFA. Requires uniqueness of element names
+
+    gfa-merge <output> <input...>
+
+    <output>     Output GFA file to be created
+    <input...>   List of input GFA files to read
+  HELP
+  exit(1)
+end
+
+gfa = GFA.new
+input.each do |i|
+  $stderr.puts "Merging GFA: #{i}"
+  gfa.merge! GFA.load(i)
+end
+
+$stderr.puts "Saving GFA: #{output}"
+gfa.save(output)
+

data/bin/gfa-paths-to-fasta

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+
+# @package MiGA
+# @license Artistic-2.0
+
+$LOAD_PATH.push File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.push File.expand_path('../../lib', File.realpath(__FILE__))
+
+require 'gfa'
+
+input, output, threads = ARGV
+
+unless output
+  $stderr.puts <<~HELP
+    Extract the sequences of the paths from a GFA to FastA file
+
+    gfa-merge <input> <output> [<threads>]
+
+    <input>      Input GFA file to read
+    <output>     Output FastA file to be created
+    <threads>    If passed, parallelize process with these many threads
+  HELP
+  exit(1)
+end
+
+$stderr.puts "Loading GFA: #{input}"
+gfa = GFA.load_parallel(input, (threads || 1).to_i)
+
+

data/lib/gfa/common.rb

@@ -61,4 +61,23 @@ class GFA
   def rebuild_index!
     @records.each_value(&:rebuild_index!)
   end
+
+  ##
+  # Computes the sum of all individual segment lengths
+  def total_length
+    segments.total_length
+  end
+
+  ##
+  # Adds the entrie of +gfa+ to itself
+  def merge!(gfa)
+    records.each { |k, v| v.merge!(gfa.records[k]) }
+    self
+  end
+
+  ##
+  # Creates a new GFA based on itself and appends all entries in +gfa+
+  def merge(gfa)
+    GFA.new(opts).merge!(self).merge!(gfa)
+  end
 end

data/lib/gfa/graph.rb

@@ -110,9 +110,9 @@ class GFA
     # Links, Containments, Jumps (from, to) and Paths (segment_names)
     linking = []
     eval_set = _ignore == 0 ? segments.set : segments.set[_ignore..]
-    edges.delete_if do |record|
-      if eval_set.any? { |segment| record.include? segment }
-        linking << record
+    edges.delete_if do |edge|
+      if eval_set.any? { |segment| edge.include? segment }
+        linking << edge
         true  # Remove from the edge set to speed up future recursions
       else
         false # Keep it, possibly linking future recursions 

data/lib/gfa/modules.rb

@@ -0,0 +1,96 @@
+
+class GFA
+  ##
+  # Find all independent modules by greedily crawling the linking entries for
+  # each segment, and returns an Array of GFA objects containing each individual
+  # module. If +recalculate+ is false, it trusts the current calculated
+  # matrix unless none exists
+  def split_modules(recalculate = true)
+    recalculate_matrix if recalculate || @matrix.nil?
+    missing_segments = (0 .. @matrix_segment_names.size - 1).to_a
+    modules = []
+    until missing_segments.empty?
+      mod = matrix_find_module(missing_segments[0])
+      mod.segments.set.map(&:name).map(&:value).each do |name|
+        missing_segments.delete(@matrix_segment_names.index(name))
+      end
+      modules << mod
+    end
+    modules
+  end
+
+  ##
+  # Finds the entire module containing the segment with index +segment_index+
+  # in the matrix (requires calling +recalculate_matrix+ first!). Returns the
+  # module as a new GFA
+  def matrix_find_module(segment_index)
+    # Initialize
+    segs = [segment_index]
+    edges = []
+    new_segs = true
+
+    # Iterate until no new segments are found
+    while new_segs
+      new_segs = false
+      segs.each do |seg|
+        @matrix.size.times do |k|
+          next if seg == k
+          v = @matrix[[seg, k].max][[seg, k].min]
+          next if v.empty?
+          edges += v
+          unless segs.include?(k)
+            new_segs = true
+            segs << k
+          end
+        end
+      end
+    end
+
+    # Save as GFA and return
+    o = GFA.new
+    segs.each { |k| o << segments[k] }
+    edges.uniq.each { |k| o << @matrix_edges[k] }
+    o
+  end
+
+  ##
+  # Calculates a matrix where all links between segments are represented by the
+  # following variables:
+  # 
+  # +@matrix_segment_names+ includes the names of all segments (as String) with
+  # the order indicating the segment index in the matrix
+  #
+  # +@matrix+ is an Array of Arrays of Arrays, where the first index indicates
+  # the row index segment, the second index indicates the column index segment,
+  # and the third index indicates each of the links between those two. Note that
+  # matrix only stores the lower triangle, so the row index must be stictly less
+  # than the column index. For example, +@matrix[3][1]+ returns an Array of all
+  # index links between the segment with index 3 and the segment with index 1:
+  # ```
+  # [
+  #   [             ], # Row 0 is always empty
+  #   [[]           ], # Row 1 stores connections to column 0
+  #   [[], []       ], # Row 2 stores connections to columns 0 and 1
+  #   [[], [], []   ], # Row 3 stores connections to columns 0, 1, and 2
+  #   ...              # &c
+  # ]
+  # ```
+  #
+  # +@matrix_edges+ is an Array of GFA::Record objects representing all edges in
+  # the GFA. The order indicates the index used by the values of +@matrix+
+  def recalculate_matrix
+    @matrix_segment_names = segments.set.map(&:name).map(&:value)
+    @matrix = @matrix_segment_names.size.times.map { |i| Array.new(i) { [] } }
+    @matrix_edges = all_edges
+    @matrix_edges.each_with_index do |edge, k|
+      names = edge.segments(self).map(&:name).map(&:value)
+      indices = names.map { |i| @matrix_segment_names.index(i) }
+      indices.each do |a|
+        indices.each do |b|
+          break if a == b
+          @matrix[[a, b].max][[a, b].min] << k
+        end
+      end
+    end
+  end
+end

data/lib/gfa/record/segment.rb

@@ -26,4 +26,10 @@ class GFA::Record::Segment < GFA::Record
     add_field(3, :Z, sequence, /\*|[A-Za-z=.]+/)
     opt_fields.each { |f| add_opt_field(f, OPT_FIELDS) }
   end
+
+  ##
+  # Returns the length of the sequence represented in this segment
+  def length
+    sequence.value.length
+  end
 end

data/lib/gfa/record_set/segment_set.rb

@@ -1,4 +1,10 @@
 class GFA::RecordSet::SegmentSet < GFA::RecordSet
   CODE = :S
   INDEX_FIELD = 2 # Name: Segment name
+
+  ##
+  # Computes the sum of all individual segment lengths
+  def total_length
+    set.map(&:length).reduce(0, :+)
+  end
 end

data/lib/gfa/version.rb

@@ -1,5 +1,5 @@
 class GFA
-  VERSION       = '0.4.0'
+  VERSION       = '0.6.0'
   VERSION_ARRAY = VERSION.split(/\./).map { |x| x.to_i } # :nodoc:
   VERSION_MAJOR = VERSION_ARRAY[0] # :nodoc:
   VERSION_MINOR = VERSION_ARRAY[1] # :nodoc:

data/lib/gfa.rb

@@ -2,3 +2,4 @@ require 'gfa/common'
 require 'gfa/parser'
 require 'gfa/generator'
 require 'gfa/graph'
+require 'gfa/modules'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gfa
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Luis M. Rodriguez-R
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-03-15 00:00:00.000000000 Z
+date: 2023-10-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rgl
@@ -64,6 +64,10 @@ files:
 - README.md
 - Rakefile
 - bin/gfa-add-gaf
+- bin/gfa-greedy-modules
+- bin/gfa-mean-depth
+- bin/gfa-merge
+- bin/gfa-paths-to-fasta
 - bin/gfa-subgraph
 - lib/gfa.rb
 - lib/gfa/common.rb
@@ -77,6 +81,7 @@ files:
 - lib/gfa/field/string.rb
 - lib/gfa/generator.rb
 - lib/gfa/graph.rb
+- lib/gfa/modules.rb
 - lib/gfa/parser.rb
 - lib/gfa/record.rb
 - lib/gfa/record/comment.rb