bioinform 0.1.6 → 0.1.7

data/TODO.txt

@@ -1,4 +1,8 @@
-Create Collection class. Rewrite MACRO-APE to use this class.
+ToDo:
+  how to make PM#equal? and PM#hash so that using PMs in Sets wouldn't destroy comparability of Sets and two sets with the same PMs(but different objects) would be equal. (also using pm as a hash-key)
+  
+Make parser exception print out text where parsing was broken (processing line +- 2 nearest lines and command and line numbers)
+Prevent parser going into infinity loop
 
 Create CLI-apps:
 -- to merge many files(or whole folder) to a Collection
@@ -10,9 +14,10 @@ Decide:
    PPM format such that parser got both matrix and count (if PPM have `word_count`)
 -- can_parse?
 -- Whether to cache suffices:  cache :best_suffix, obsolete: [:discrete!, :background!, ...]
+-- behaviour of PM#== for PMs with different tags
+-- should background be in PM by default?
+-- refactor PM.new #== and so on to make possible consistently introduce or remove a variable at a single line
+-- Make PCM#valid? and PPM#valid? more specific. This shouldn't destroy functionality to load arbitrary data as matrix, but only in force mode (I don't understand yet where should it be: in a constructor or where? And which validation-"severity" levels should be? Strong validation - size-only-validation - size-and-type-validation - no validation ???  or may be  options: valid_strictness: 'strict', 'usual', 'strict_with_name' ??? It should be considered)
 
 Specs
--- PM#==  (!)
--- PWM#probabilities, #score_variance, #gauss_estimation
--- pcm2pwm
--- split_motifs
+-- PWM#probabilities, #score_variance, #gauss_estimation

data/bioinform.gemspec

@@ -8,7 +8,7 @@ Gem::Specification.new do |gem|
   gem.summary       = %q{Classes for work with different input formats of positional matrices and IUPAC-words and making simple transform and statistics with them. Also module includes several useful extensions for Enumerable module like parametric map and callable symbols }
   gem.homepage      = ""
 
-  gem.files         = `git ls-files`.split($\)
+  gem.files         = `git ls-files`.split($/)
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.name          = "bioinform"

data/lib/bioinform/cli/pcm2pwm.rb

@@ -13,7 +13,7 @@ When filelist is empty, it's obtained from STDIN. One can use it: `ls -b pcm_fol
 
 Usage:
   #{__FILE__} [options] [<pcm-files>...]
-  
+
 Options:
   -h --help           Show this screen.
   -e --extension EXT  Extension of output files [default: pwm]
@@ -21,27 +21,27 @@ Options:
         DOCOPT
 
         options = Docopt::docopt(doc, argv: argv)
-        
+
         if options['<pcm-files>'].empty?
           filelist = $stdin.read.shellsplit
         else
           filelist = options['<pcm-files>']
         end
-        
+
         folder = options['--folder']
         Dir.mkdir(folder)  unless Dir.exist?(folder)
-        
+
         filelist.each do |pcm_filename|
           pwm = Bioinform::PCM.new( File.read(pcm_filename) ).to_pwm
           File.open(Bioinform::CLI.output_filename(pcm_filename, options['--extension'], folder), 'w') do |f|
             f.puts pwm
           end
         end
-        
+
       rescue Docopt::Exit => e
         puts e.message
       end
-      
+
     end
   end
 end

data/lib/bioinform/cli/split_motifs.rb

@@ -4,7 +4,7 @@ require 'docopt'
 module Bioinform
   module CLI
     module SplitMotifs
-      
+
       def self.main(argv)
         doc = <<-DOCOPT
 Motif splitter.
@@ -12,7 +12,7 @@ It get a file with a set of motifs and splits it into motifs according to their
 
 Usage:
   #{__FILE__} [options] <collection-file>
-  
+
 Options:
   -h --help                Show this screen.
   -m --data-model MODEL    Data model: PM, PCM, PPM or PWM [default: PM]
@@ -21,17 +21,17 @@ Options:
         DOCOPT
 
         options = Docopt::docopt(doc, argv: argv)
-        
+
         folder = options['--folder']
         Dir.mkdir(folder)  unless Dir.exist?(folder)
-        
+
         data_model = Bioinform.const_get(options['--data-model'].upcase)
         extension = options['--extension'] || options['--data-model'].downcase
-        
+
         collection_filename = options['<collection-file>']
         raise "File #{collection_filename} not exist"  unless File.exist? collection_filename
         input = File.read(collection_filename)
-        
+
         data_model.choose_parser(input).split_on_motifs(input, data_model).each do |motif|
           File.open(File.join(folder, "#{motif.name}.#{extension}"), 'w') do |f|
             f.puts motif
@@ -40,7 +40,7 @@ Options:
       rescue Docopt::Exit => e
         puts e.message
       end
-      
+
     end
   end
 end

data/lib/bioinform/data_models.rb

@@ -5,5 +5,7 @@ require 'bioinform/data_models/pcm'
 require 'bioinform/data_models/ppm'
 require 'bioinform/data_models/pwm'
 
+require 'bioinform/data_models/collection'
+
 #require 'bioinform/data_models/iupac_word'
 #require 'bioinform/data_models/iupac_wordset'

data/lib/bioinform/data_models/collection.rb

@@ -1,2 +1,86 @@
-class PMCollection
+require 'ostruct'
+
+module Bioinform
+  class Collection
+    attr_reader :collection, :parameters
+
+    # collection name is a tag name for each motif in a collection. But motif can be included in several collections so have several tags
+    def initialize(parameters = {})
+      @collection = []
+      @parameters = OpenStruct.new(parameters)
+      yield @parameters  if block_given?
+    end
+
+    def size
+      collection.size
+    end
+
+    def name
+      parameters.name
+    end
+
+    def to_s
+      "<Collection '#{name}'>"
+    end
+    
+    def +(other)
+      result = self.class.new
+      each do |pm, infos|
+        result.add_pm(pm, infos)
+      end
+      other.each do |pm, infos|
+        result.add_pm(pm, infos)
+      end
+      result
+    end
+
+    def add_pm(pm, info)
+      pm.mark(self)
+      collection << [pm, info]
+      self
+    end
+    
+    def <<(pm)
+      add_pm(pm, OpenStruct.new)
+    end
+
+    def each
+      if block_given?
+        collection.each{|pm, infos| yield [pm, infos]}
+      else
+        Enumerator.new(self, :each)
+      end
+    end
+    
+    def each_pm
+      if block_given?
+        each{|pm, infos| yield pm}
+      else
+        Enumerator.new(self, :each_pm)
+      end
+    end
+
+    include Enumerable
+
+    %w[pcm ppm pwm].each do |data_model|
+      method_name = "each_#{data_model}".to_sym       #
+      converter_method = "to_#{data_model}".to_sym    #
+      define_method method_name do |&block|           # define_method :each_pcm do |&block|
+        if block                                      #   if block
+          each do |pm, infos|                         #     each do |pm, infos|
+            block.call pm.send(converter_method)      #       block.call pm.send(:to_pcm)
+          end                                         #     end
+        else                                          #   else
+          Enumerator.new(self, method_name)           #     Enumerator.new(self, :each_pcm)
+        end                                           #   end
+      end                                             # end
+    end
+    
+    def ==(other)
+      (collection == other.collection) && (parameters == other.parameters)
+    rescue
+      false
+    end
+
+  end
 end

data/lib/bioinform/data_models/pcm.rb

@@ -6,20 +6,23 @@ module Bioinform
     def count
       matrix.first.inject(&:+)
     end
-    
+
+    def to_pcm
+      self
+    end
+
     def to_pwm(pseudocount = Math.log(count))
       mat = each_position.map do |pos|
         pos.each_index.map do |ind|
           Math.log((pos[ind] + probability[ind] * pseudocount) / (probability[ind]*(count + pseudocount)) )
         end
       end
-      PWM.new(matrix: mat, name: name)
+      PWM.new(matrix: mat, name: name, tags: tags, background: background)
     end
-    
+
     def to_ppm
       mat = each_position.map{|pos| pos.map{|el| el.to_f / count }}
-      PPM.new(matrix: mat, name: name)
+      PPM.new(matrix: mat, name: name, tags: tags, background: background)
     end
-
   end
 end

data/lib/bioinform/data_models/pm.rb

@@ -4,45 +4,56 @@ require 'bioinform/parsers'
 module Bioinform
   IndexByLetter = {'A' => 0, 'C' => 1, 'G' => 2, 'T' => 3, A: 0, C: 1, G: 2, T: 3}
   LetterByIndex = {0 => :A, 1 => :C, 2 => :G, 3 => :T}
-  
+
   class PM
-    attr_reader :matrix
+    attr_reader :matrix, :tags
     attr_accessor :background, :name
-    
+
+    def mark(tag)
+      tags << tag
+    end
+
+    def tagged?(tag)
+      tags.any?{|t| (t.eql? tag) || (t.respond_to?(:name) && t.name && (t.name == tag)) }
+    end
+
     def self.choose_parser(input)
       [TrivialParser, Parser, StringParser, StringFantomParser].find do |parser|
         self.new(input, parser) rescue nil
       end
     end
-    
+
     def initialize(input, parser = nil)
       parser ||= self.class.choose_parser(input)
       raise 'No one parser can process input'  unless parser
       result = parser.new(input).parse
       @matrix = result[:matrix]
       @name = result[:name]
-      @background = [1, 1, 1, 1]
+      @tags = result[:tags] || []
+      @background = result[:background] || [1, 1, 1, 1]
       raise 'matrix not valid'  unless valid?
     end
-    
+
     def ==(other)
-      @matrix == other.matrix && @background == other.background
+      @matrix == other.matrix && @background == other.background && @name == other.name
+    rescue
+      false
     end
-    
+
     def self.valid_matrix?(matrix)
       matrix.is_a?(Array) &&
       ! matrix.empty? &&
       matrix.all?{|pos| pos.is_a?(Array)} &&
       matrix.all?{|pos| pos.size == 4} &&
       matrix.all?{|pos| pos.all?{|el| el.is_a?(Numeric)}}
-    rescue 
+    rescue
       false
     end
-    
+
     def valid?
       self.class.valid_matrix?(@matrix)
     end
-    
+
     def each_position
       if block_given?
         matrix.each{|pos| yield pos}
@@ -50,12 +61,12 @@ module Bioinform
         Enumerator.new(self, :each_position)
       end
     end
-        
+
     def length
       @matrix.length
     end
     alias_method :size, :length
-    
+
     def to_s(options = {})
       default_options = {with_name: true, letters_as_rows: false}
       options = default_options.merge(options)
@@ -65,41 +76,41 @@ module Bioinform
       else
         matrix_str = each_position.map{|pos| pos.join("\t")}.join("\n")
       end
-      
-      if options[:with_name] && @name 
+
+      if options[:with_name] && @name
         @name + "\n" + matrix_str
-      else 
+      else
         matrix_str
       end
     end
-    
+
     def pretty_string(options = {})
       default_options = {with_name: true, letters_as_rows: false}
-      
+
       return to_s(options)  if options[:letters_as_rows]
-      
+
       options = default_options.merge(options)
       header = %w{A C G T}.map{|el| el.rjust(4).ljust(7)}.join + "\n"
       matrix_rows = each_position.map do |position|
         position.map{|el| el.round(3).to_s.rjust(6)}.join(' ')
       end
-      
+
       matrix_str = matrix_rows.join("\n")
-      
+
       if options[:with_name] && @name
         @name + "\n" + header + matrix_str
       else
         header + matrix_str
       end
     end
-    
+
     def to_hash
-      hsh = %w{A C G T}.each_with_index.collect_hash do |letter, letter_index| 
+      hsh = %w{A C G T}.each_with_index.collect_hash do |letter, letter_index|
         [ letter, @matrix.map{|pos| pos[letter_index]} ]
       end
       hsh.with_indifferent_access
     end
-    
+
     # pm.background - returns a @background attribute
     # pm.background(new_background) - sets an attribute and returns pm itself
     # if more than one argument passed - raises an exception
@@ -110,17 +121,17 @@ module Bioinform
       else raise ArgumentError, '#background method can get 0 or 1 argument'
       end
     end
-    
+
     def background!(new_background)
       @background = new_background
       self
     end
-    
+
     def self.zero_column
       [0, 0, 0, 0]
     end
 
-    def reverse_complement!      
+    def reverse_complement!
       @matrix.reverse!.map!(&:reverse!)
       self
     end
@@ -132,10 +143,7 @@ module Bioinform
       n.times{ @matrix.push(self.class.zero_column) }
       self
     end
-    def shift_to_zero! # make worst score == 0 by shifting scores of each column
-      @matrix.map!{|position| min = position.min; position.map{|element| element - min}}
-      self
-    end
+
     def discrete!(rate)
       @matrix.map!{|position| position.map{|element| (element * rate).ceil}}
       self
@@ -144,13 +152,12 @@ module Bioinform
     def vocabulary_volume
       background.inject(&:+) ** length
     end
-    
+
     def probability
       sum = background.inject(0.0, &:+)
       background.map{|element| element.to_f / sum}
     end
 
-
     #def split(first_chunk_length)
     #  [@matrix.first(first_chunk_length), matrix.last(length - first_chunk_length)]
     #end
@@ -164,16 +171,16 @@ module Bioinform
     def worst_score
       @matrix.inject(0.0){|sum, col| sum + col.min}
     end
-    
+
     # best score of suffix s[i..l]
     def best_suffix(i)
       @matrix[i...length].map(&:max).inject(0.0, &:+)
     end
-    
+
     def worst_suffix(i)
       @matrix[i...length].map(&:min).inject(0.0, &:+)
     end
-    
+
     def reverse_complement
       dup.reverse_complement!
     end
@@ -183,14 +190,22 @@ module Bioinform
     def right_augment(n)
       dup.right_augment!(n)
     end
-    def shift_to_zero
-      dup.shift_to_zero!
-    end
     def discrete(rate)
       dup.discrete!(rate)
     end
     def dup
       deep_dup
     end
+
+    def to_pcm
+      PCM.new(matrix: matrix, name: name, tags: tags, background: background)
+    end
+    def to_ppm
+      PPM.new(matrix: matrix, name: name, tags: tags, background: background)
+    end
+    def to_pwm
+      PWM.new(matrix: matrix, name: name, tags: tags, background: background)
+    end
+
   end
 end