tree_clusters 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 612ebc10d0f23a15ae9d11d35be3f1de197d29fd
-  data.tar.gz: '084ff094f024a062e1c0f1476b9105950f796edf'
+  metadata.gz: e6f0523128e1d9efede01f9af494d99e7e51a48c
+  data.tar.gz: 58bac03495f585ad2ea755abaac5ceefdb90e2d3
 SHA512:
-  metadata.gz: 247778fdebedd3213d96ccafc52ce1d5667bdb9e8eefee60e30b3dbf1fa618ea73000d6d2a5802e47e84d9ba6fa4c119fd3acb1d21907c4c268f63e38949ffcd
-  data.tar.gz: e8d5cc7d6aa7ce86f277f42c5a5b8bd7b7d2bebe5ac3fbf5c4201315bc7aa8e411940056c30dce22226864d982083605180bfe7304c824566e107a43a308c910
+  metadata.gz: 73a82096be4f5be8199be28bf3e12b0ac63c08b9da1cfea1fded6cd4da7c448ffc7cdc8a285c681b88493b39fa32fcace02be0fff23190a314050d107db4b2f5
+  data.tar.gz: a5b00bec9a4f567efc098e664e6479e691f96e761a5c57ac5e4f198159c9d1cfd320dbb2033a1a458597460f621815e03ee6ecef351f31db4597f4a0a7aac838

data/exe/clade_attrs

@@ -0,0 +1,229 @@
+#!/usr/bin/env ruby
+
+Signal.trap("PIPE", "EXIT")
+
+require "tree_clusters"
+require "trollop"
+require "parse_fasta"
+require "shannon"
+require "fileutils"
+
+TreeClusters.extend TreeClusters
+
+def puts_info outf, clade_id, attr_cat, attr_set
+  outf.puts [clade_id, attr_cat, attr_set.to_a].join "\t"
+end
+
+opts = Trollop.options do
+  version TreeClusters::VERSION
+
+  banner <<-EOS
+
+
+  Checking IDs
+  ------------
+
+  IDs for the sequences must match between the three input files.
+
+  The tree file is allowed to have quoted taxa names, but the mapping
+  file and alignment file are not.
+
+  If your alignment file has spaces in the name, the ID part of the
+  header (i.e., the part up until the space) must match with the
+  sequence IDs in the tree and the mapping file.
+
+  Example: This would be okay.
+
+  tree file:
+    ('genome_A', 'genome_B');
+
+  aln file:
+    >genome_A apple pie
+    AAAAA
+    >genome_B brown sugar
+    AATTA
+
+  mapping file:
+    name	coolness
+    genome_A	cool
+    genome_B	notcool
+
+
+  Subtracting parent nodes
+  ------------------------
+
+  If a clade's parent would be the root of the tree, no columns will
+  be subtracted when removing the parent columns as it would be the
+  entire alignment.
+
+  Options:
+  EOS
+
+  opt(:tree,
+      "Newick tree file",
+      type: :string)
+  opt(:mapping,
+      "Mapping file",
+      type: :string)
+  opt(:attrs,
+      "Attributes file",
+      type: :string)
+
+  opt(:clade_size_cutoff,
+      "Consider only clades with at least this many leaves",
+      default: 1)
+
+  opt(:outdir,
+      "Output directory",
+      default: ".")
+  opt(:base,
+      "Basename for output",
+      default: "clade_attrs")
+end
+
+abort_if opts[:tree].nil?,
+         "--tree is a required arg"
+abort_if opts[:mapping].nil?,
+         "--mapping is a required arg"
+abort_if opts[:attrs].nil?,
+         "--attrs is a required arg"
+
+abort_unless_file_exists opts[:tree]
+abort_unless_file_exists opts[:mapping]
+abort_unless_file_exists opts[:attrs]
+
+# TODO check IDs when attrs is not a fasta file
+# TreeClusters.check_ids opts[:tree], opts[:mapping], opts[:attrs]
+
+abort_unless opts[:clade_size_cutoff] >= 1,
+             "--clade-size-cutoff must be >= 1"
+
+FileUtils.mkdir_p opts[:outdir]
+
+tree                   = NewickTree.fromFile opts[:tree]
+metadata               = TreeClusters.read_mapping_file opts[:mapping]
+snazzy_info            = TreeClusters.snazzy_info tree, metadata
+attr_names, leaf2attrs = TreeClusters.read_attrs_file opts[:attrs]
+
+ext_base = "clade_attrs"
+
+clades_fname  =
+  File.join opts[:outdir],
+            "#{opts[:base]}.#{ext_base}.txt"
+members_fname =
+  File.join opts[:outdir],
+            "#{opts[:base]}.#{ext_base}_clade_members.txt"
+attrs_fname =
+  File.join opts[:outdir],
+            "#{opts[:base]}.#{ext_base}_attrs_union.txt"
+attrs_intersection_fname =
+  File.join opts[:outdir],
+            "#{opts[:base]}.#{ext_base}_attrs_intersection.txt"
+attrs_minus_parent_attrs_fname =
+  File.join opts[:outdir],
+            "#{opts[:base]}.#{ext_base}_attrs_minus_parent_attrs.txt"
+attrs_minus_sibling_attrs_fname =
+  File.join opts[:outdir],
+            "#{opts[:base]}.#{ext_base}_attrs_minus_sibling_attrs.txt"
+attrs_minus_other_attrs_fname =
+  File.join opts[:outdir],
+            "#{opts[:base]}.#{ext_base}_attrs_minus_other_attrs.txt"
+
+
+info_f =
+  File.open(clades_fname, "w")
+clade_members_f =
+  File.open(members_fname, "w")
+attrs_f =
+  File.open(attrs_fname, "w")
+attrs_intersection_f =
+  File.open(attrs_intersection_fname, "w")
+attrs_minus_parent_attrs_f =
+  File.open(attrs_minus_parent_attrs_fname, "w")
+attrs_minus_sibling_attrs_f =
+  File.open(attrs_minus_sibling_attrs_fname, "w")
+attrs_minus_other_attrs_f =
+  File.open(attrs_minus_other_attrs_fname, "w")
+
+
+begin
+  # info is { metadata_category => metadata_tag , ... }
+  snazzy_info.each_with_index do |(clade, info), idx|
+    assert clade.all_leaves.all? { |leaf| leaf2attrs.has_key? leaf },
+           "Not all leaves are present in the leaf2attrs hash table"
+
+    clade_id = "clade_#{idx+1}___#{clade.name}"
+
+    is_snazzy = info.nil? ? false : true
+    snazzy = is_snazzy ? "snazzy" : "not_snazzy"
+
+    if is_snazzy
+      info_f.puts [clade_id,
+                   info.count,
+                   info.map { |pair| pair.join("|")}].join "\t"
+    else
+      info_f.puts [clade_id,
+                   0,
+                   "not_snazzy"].join "\t"
+    end
+
+    clade_members_f.puts [clade_id,
+                          clade.all_leaves.count,
+                          clade.all_leaves].join "\t"
+
+    attr_names.each do |attr_category|
+      attrs_all_leaves =
+        leaf2attrs.attrs clade.all_leaves, attr_category
+
+      attrs_all_sibling_leaves =
+        leaf2attrs.attrs clade.all_sibling_leaves,
+                         attr_category
+      attrs_parent_leaves =
+        leaf2attrs.attrs clade.parent_leaves,
+                         attr_category
+      attrs_other_leaves =
+        leaf2attrs.attrs clade.other_leaves,
+                         attr_category
+
+      attrs_all_minus_parent =
+        attrs_all_leaves.union - attrs_parent_leaves.union
+      attrs_all_minus_sibling =
+        attrs_all_leaves.union - attrs_all_sibling_leaves.union
+      attrs_all_minus_other =
+        attrs_all_leaves.union - attrs_other_leaves.union
+
+
+      puts_info attrs_f,
+                clade_id,
+                attr_category,
+                attrs_all_leaves.union
+
+      puts_info attrs_intersection_f,
+                clade_id,
+                attr_category,
+                attrs_all_leaves.intersection
+
+      puts_info attrs_minus_parent_attrs_f,
+                clade_id,
+                attr_category,
+                attrs_all_minus_parent
+
+      puts_info attrs_minus_sibling_attrs_f,
+                clade_id,
+                attr_category,
+                attrs_all_minus_sibling
+
+      puts_info attrs_minus_other_attrs_f,
+                clade_id,
+                attr_category,
+                attrs_all_minus_other
+    end
+  end
+ensure
+  info_f.close
+  clade_members_f.close
+  attrs_f.close
+  attrs_minus_parent_attrs_f.close
+  attrs_minus_sibling_attrs_f.close
+  attrs_minus_other_attrs_f.close
+end

data/lib/tree_clusters/attr_array.rb

@@ -0,0 +1,18 @@
+module TreeClusters
+  # Provides convenience methods for working with Arrays of Sets
+  class AttrArray < Object::Array
+    # Takes the union of all sets in the AttrArray
+    #
+    # @return [Set]
+    def union
+      self.reduce(&:union)
+    end
+
+    # Takes the intersection of all sets in the AttrArray
+    #
+    # @return [Set]
+    def intersection
+      self.reduce(&:intersection)
+    end
+  end
+end

data/lib/tree_clusters/attrs.rb

@@ -0,0 +1,47 @@
+module TreeClusters
+  # A Hash table for genome/leaf/taxa attributes
+  class Attrs < Hash
+
+    # Returns the an AttrArray of Sets for the given genomes and
+    # attribute.
+    #
+    # @note If a genome is in the leaves array, but is not in the hash
+    #   table, NO error will be raised. Rather that genome will be
+    #   skipped. This is for cases in which not all genomes have
+    #   attributes.
+    #
+    # @param leaves [Array<String>] names of the leaves for which you
+    #   need attributes
+    # @param attr [Symbol] the attribute you are interested in eg,
+    #   :genes
+    #
+    # @return [AttrArray<Set>] an AttrArray of Sets of
+    #   attributes
+    #
+    # @raise [AbortIf::Exit] if they leaf is present but doesn't have
+    #   the requested attr
+    def attrs leaves, attr
+      ary = leaves.map do |leaf|
+
+        if self.has_key? leaf
+          abort_unless self[leaf].has_key?(attr),
+                       "Missing attr #{attr.inspect} for leaf '#{leaf}'"
+
+          self[leaf][attr]
+        else
+          nil
+        end
+      end.compact
+
+      TreeClusters::AttrArray.new ary
+    end
+
+    def add leaf, attr, val
+      if self.has_key? leaf
+        self[leaf][attr] = val
+      else
+        self[leaf] = { attr => val }
+      end
+    end
+  end
+end

data/lib/tree_clusters/clade.rb

@@ -0,0 +1,128 @@
+module TreeClusters
+  # Represents a clade in a NewickTree
+  class Clade
+    attr_accessor :name,
+                  :all_leaves,
+                  :left_leaves,
+                  :right_leaves,
+                  :all_sibling_leaves,
+                  :each_sibling_leaf_set,
+                  :parent_leaves,
+                  :non_parent_leaves,
+                  :other_leaves,
+                  :single_tag_info,
+                  :all_tags
+
+    # @note If a node name is quoted, then those quotes are removed
+    #   first.
+    #
+    # @param node [NewickNode] a NewickNode from a NewickTree
+    # @param tree [NewickTree] a NewickTree
+    def initialize node, tree, metadata=nil
+      tree_taxa = tree.unquoted_taxa
+
+      @name = unquote node.name
+      @all_leaves = descendant_leaves node
+
+      if (children = node.children).count == 2
+        lchild, rchild = node.children
+
+        @left_leaves = descendant_leaves lchild
+
+        @right_leaves = descendant_leaves rchild
+      end
+
+      siblings = node.siblings
+      # assert siblings.count == 1,
+      #        "Node #{node.name} has more than one sibling."
+
+      @each_sibling_leaf_set = siblings.
+                               map { |node| descendant_leaves node }
+
+      @all_sibling_leaves = @each_sibling_leaf_set.flatten.uniq
+
+      parent = node.parent
+      assert parent,
+             "Noge #{node.name} has no parent. Is it the root?"
+      @parent_leaves = descendant_leaves parent
+
+      @other_leaves =
+        Object::Set.new(tree_taxa) - Object::Set.new(all_leaves)
+
+      @non_parent_leaves =
+        Object::Set.new(tree_taxa) - Object::Set.new(parent_leaves)
+
+      if metadata
+        @metadata = metadata
+        @all_tags ||= get_all_tags
+        @single_tag_info ||= get_single_tag_info
+      else
+        @single_tag_info = nil
+      end
+    end
+
+    # Compares two Clades field by field.
+    #
+    # If all instance variables are == than the two clades are == as
+    # well.
+    def == clade
+      (
+        self.name == clade.name &&
+        self.all_leaves == clade.all_leaves &&
+        self.left_leaves == clade.left_leaves &&
+        self.right_leaves == clade.right_leaves &&
+        self.all_sibling_leaves == clade.all_sibling_leaves &&
+        self.each_sibling_leaf_set == clade.each_sibling_leaf_set &&
+        self.parent_leaves == clade.parent_leaves &&
+        self.other_leaves == clade.other_leaves &&
+        self.single_tag_info == clade.single_tag_info &&
+        self.all_tags == clade.all_tags
+      )
+    end
+
+    # Alias for ==
+    def eql? clade
+      self == clade
+    end
+
+    private
+
+    def get_single_tag_info
+      @all_tags.map do |md_cat, set|
+        [md_cat, set.count == 1 ? set.to_a.first : nil]
+      end.to_h
+    end
+
+    def get_all_tags
+      # name2tag has leaf names => metadata tag and is an Attrs
+      @metadata.map do |md_cat, name2tag|
+        tag_info = self.all_leaves.map do |leaf|
+          assert name2tag.has_key?(leaf),
+                 "leaf #{leaf} is not present in name2tag ht for " +
+                 "md_cat #{md_cat}"
+
+          name2tag[leaf]
+        end
+
+        [md_cat, Set.new(tag_info)]
+      end.to_h
+    end
+
+    def descendant_leaves node
+      if node.leaf?
+        [unquote(node.name)]
+      else
+        node.
+          descendants.
+          flatten.
+          uniq.
+          select { |node| node.leaf? }.
+          map { |node| unquote(node.name) }
+      end
+    end
+
+    def unquote str
+      str.tr %q{"'}, ""
+    end
+  end
+end

data/lib/tree_clusters/version.rb

@@ -1,3 +1,3 @@
 module TreeClusters
-  VERSION = "0.6.0"
+  VERSION = "0.7.0"
 end

data/lib/tree_clusters.rb

@@ -3,6 +3,9 @@ require "Newick"
 require "set"
 require "parse_fasta"
 require "shannon"
+require "tree_clusters/attrs"
+require "tree_clusters/attr_array"
+require "tree_clusters/clade"
 require "tree_clusters/version"
 
 include AbortIf
@@ -198,6 +201,73 @@ module TreeClusters
     snazzy_clades
   end
 
+  def snazzy_info tree, metadata
+    snazzy_info = {}
+
+    clades = self.
+             all_clades(tree, metadata).
+             sort_by { |clade| clade.all_leaves.count }.
+             reverse
+
+    # Non snazzy clades have a value of nil, so set all to nil and the
+    # snazzy ones will be overwritten.
+    clades.each do |clade|
+      snazzy_info[clade] = nil
+    end
+
+    metadata.each do |md_cat, leaf2mdtag|
+      already_checked = Set.new
+      single_tag_clades = {}
+
+      clades.each do |clade|
+        assert clade.all_leaves.count > 1,
+               "A clade cannot also be a leaf"
+
+        unless clade.all_leaves.all? do |leaf|
+                 already_checked.include? leaf
+               end
+          md_tags = clade.all_leaves.map do |leaf|
+            assert leaf2mdtag.has_key?(leaf),
+                   "leaf #{leaf} is missing from leaf2mdtag ht"
+
+            leaf2mdtag[leaf]
+          end
+
+          # this clade is mono-phyletic w.r.t. this metadata category.
+          if md_tags.uniq.count == 1
+            clade.all_leaves.each do |leaf|
+              already_checked << leaf
+            end
+
+            assert !single_tag_clades.has_key?(clade),
+                   "clade #{clade.name} is repeated in single_tag_clades for #{md_cat}"
+
+            single_tag_clades[clade] = md_tags.first
+          end
+        end
+      end
+
+      single_tag_clades.each do |clade, md_tag|
+        non_clade_leaves = tree.unquoted_taxa - clade.all_leaves
+
+        non_clade_leaves_with_this_md_tag = non_clade_leaves.map do |leaf|
+          [leaf, leaf2mdtag[leaf]]
+        end.select { |ary| ary.last == md_tag }
+
+        is_snazzy_clade = non_clade_leaves_with_this_md_tag.count.zero?
+        if is_snazzy_clade
+          if !snazzy_info[clade].nil?
+            snazzy_info[clade][md_cat] = md_tag
+          else
+            snazzy_info[clade] = { md_cat => md_tag }
+          end
+        end
+      end
+    end
+
+    snazzy_info
+  end
+
   def read_mapping_file fname
     md_cat_names = nil
     metadata = TreeClusters::Attrs.new
@@ -255,194 +325,4 @@ module TreeClusters
 
       [attr_names, attrs]
   end
-
-  # A Hash table for genome/leaf/taxa attributes
-  class Attrs < Hash
-
-    # Returns the an AttrArray of Sets for the given genomes and
-    # attribute.
-    #
-    # @note If a genome is in the leaves array, but is not in the hash
-    #   table, NO error will be raised. Rather that genome will be
-    #   skipped. This is for cases in which not all genomes have
-    #   attributes.
-    #
-    # @param leaves [Array<String>] names of the leaves for which you
-    #   need attributes
-    # @param attr [Symbol] the attribute you are interested in eg,
-    #   :genes
-    #
-    # @return [AttrArray<Set>] an AttrArray of Sets of
-    #   attributes
-    #
-    # @raise [AbortIf::Exit] if they leaf is present but doesn't have
-    #   the requested attr
-    def attrs leaves, attr
-      ary = leaves.map do |leaf|
-
-        if self.has_key? leaf
-          abort_unless self[leaf].has_key?(attr),
-                       "Missing attr #{attr.inspect} for leaf '#{leaf}'"
-
-          self[leaf][attr]
-        else
-          nil
-        end
-      end.compact
-
-      TreeClusters::AttrArray.new ary
-    end
-
-    def add leaf, attr, val
-      if self.has_key? leaf
-        self[leaf][attr] = val
-      else
-        self[leaf] = { attr => val }
-      end
-    end
-  end
-
-  # Provides convenience methods for working with Arrays of Sets
-  class AttrArray < Object::Array
-    # Takes the union of all sets in the AttrArray
-    #
-    # @return [Set]
-    def union
-      self.reduce(&:union)
-    end
-
-    # Takes the intersection of all sets in the AttrArray
-    #
-    # @return [Set]
-    def intersection
-      self.reduce(&:intersection)
-    end
-  end
-
-  # Represents a clade in a NewickTree
-  class Clade
-    attr_accessor :name,
-                  :all_leaves,
-                  :left_leaves,
-                  :right_leaves,
-                  :all_sibling_leaves,
-                  :each_sibling_leaf_set,
-                  :parent_leaves,
-                  :non_parent_leaves,
-                  :other_leaves,
-                  :single_tag_info,
-                  :all_tags
-
-    # @note If a node name is quoted, then those quotes are removed
-    #   first.
-    #
-    # @param node [NewickNode] a NewickNode from a NewickTree
-    # @param tree [NewickTree] a NewickTree
-    def initialize node, tree, metadata=nil
-      tree_taxa = tree.unquoted_taxa
-
-      @name = unquote node.name
-      @all_leaves = descendant_leaves node
-
-      if (children = node.children).count == 2
-        lchild, rchild = node.children
-
-        @left_leaves = descendant_leaves lchild
-
-        @right_leaves = descendant_leaves rchild
-      end
-
-      siblings = node.siblings
-      # assert siblings.count == 1,
-      #        "Node #{node.name} has more than one sibling."
-
-      @each_sibling_leaf_set = siblings.
-                               map { |node| descendant_leaves node }
-
-      @all_sibling_leaves = @each_sibling_leaf_set.flatten.uniq
-
-      parent = node.parent
-      assert parent,
-             "Noge #{node.name} has no parent. Is it the root?"
-      @parent_leaves = descendant_leaves parent
-
-      @other_leaves =
-        Object::Set.new(tree_taxa) - Object::Set.new(all_leaves)
-
-      @non_parent_leaves =
-        Object::Set.new(tree_taxa) - Object::Set.new(parent_leaves)
-
-      if metadata
-        @metadata = metadata
-        @all_tags ||= get_all_tags
-        @single_tag_info ||= get_single_tag_info
-      else
-        @single_tag_info = nil
-      end
-    end
-
-    # Compares two Clades field by field.
-    #
-    # If all instance variables are == than the two clades are == as
-    # well.
-    def == clade
-      (
-        self.name == clade.name &&
-        self.all_leaves == clade.all_leaves &&
-        self.left_leaves == clade.left_leaves &&
-        self.right_leaves == clade.right_leaves &&
-        self.all_sibling_leaves == clade.all_sibling_leaves &&
-        self.each_sibling_leaf_set == clade.each_sibling_leaf_set &&
-        self.parent_leaves == clade.parent_leaves &&
-        self.other_leaves == clade.other_leaves &&
-        self.single_tag_info == clade.single_tag_info &&
-        self.all_tags == clade.all_tags
-      )
-    end
-
-    # Alias for ==
-    def eql? clade
-      self == clade
-    end
-
-    private
-
-    def get_single_tag_info
-      @all_tags.map do |md_cat, set|
-        [md_cat, set.count == 1 ? set.to_a.first : nil]
-      end.to_h
-    end
-
-    def get_all_tags
-      # name2tag has leaf names => metadata tag and is an Attrs
-      @metadata.map do |md_cat, name2tag|
-        tag_info = self.all_leaves.map do |leaf|
-          assert name2tag.has_key?(leaf),
-                 "leaf #{leaf} is not present in name2tag ht for " +
-                 "md_cat #{md_cat}"
-
-          name2tag[leaf]
-        end
-
-        [md_cat, Set.new(tag_info)]
-      end.to_h
-    end
-
-    def descendant_leaves node
-      if node.leaf?
-        [unquote(node.name)]
-      else
-        node.
-          descendants.
-          flatten.
-          uniq.
-          select { |node| node.leaf? }.
-          map { |node| unquote(node.name) }
-      end
-    end
-
-    def unquote str
-      str.tr %q{"'}, ""
-    end
-  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tree_clusters
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Ryan Moore
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-11-03 00:00:00.000000000 Z
+date: 2017-11-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -172,6 +172,7 @@ description: Snazzy code for working with each cluster in a tree.
 email:
 - moorer@udel.edu
 executables:
+- clade_attrs
 - snazzy_clades
 - snazzy_clades_attrs
 - snazzy_clades_key_cols
@@ -188,10 +189,14 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- exe/clade_attrs
 - exe/snazzy_clades
 - exe/snazzy_clades_attrs
 - exe/snazzy_clades_key_cols
 - lib/tree_clusters.rb
+- lib/tree_clusters/attr_array.rb
+- lib/tree_clusters/attrs.rb
+- lib/tree_clusters/clade.rb
 - lib/tree_clusters/version.rb
 - test_files/bad.aln
 - test_files/non_bifurcating.aln