wrnap 0.0.1

data/lib/wrnap/package/population.rb

@@ -0,0 +1,84 @@
+module Wrnap
+  module Package
+    class Population < Base
+      THREE_COLUMN_REGEX = /^([+-]\d+\.\d+\t){2}[+-]\d+\.\d+$/
+
+      attr_reader :str_1_to_str_2, :str_1_to_str_1
+
+      self.default_flags = ->(context, flags) do
+        {
+          "-fftbor2d-i" => context.data.seq,
+          "-fftbor2d-j" => context.data.str_1,
+          "-fftbor2d-k" => context.data.str_2,
+          "-spectral-i" => -10,
+          "-spectral-j" => 10,
+          "-spectral-p" => 1e-2,
+        }
+      end
+      self.quote_flag_params = %w|-fftbor2d-i -fftbor2d-j -fftbor2d-k|
+
+      class PopulationProportion
+        include Enumerable
+
+        attr_reader :proportion_over_time
+
+        def initialize(time, proportion)
+          @proportion_over_time = time.zip(proportion)
+        end
+
+        def time_range(from, to)
+          proportion_over_time.select { |time, _| ((from.to_f)..(to.to_f)) === time }
+        end
+
+        def equilibrium(percentile: 95, window_size: 5, epsilon: 1e-4)
+          start       = proportion_points.first
+          stop        = proportion_points.last
+          sign        = stop > start ? :increasing : :decreasing
+          # If the population is increasing over time, we want the 95%, otherwise we want the 5%
+          spread_100  = (start.zero? || stop.zero? ? [start, stop].max : (stop / start).abs) / 100
+          # Look for the first index at the percentile we're interested in, and scan to the right from there.
+          start_index = proportion_points.each_with_index.find do |proportion, i|
+            case sign
+            when :increasing then proportion > (stop - (spread_100 * (100 - percentile)))
+            when :decreasing then proportion < (stop + (spread_100 * (100 - percentile)))
+            end
+          end.last
+
+          # The first slice starting at x we find where abs(p(x + i), p(x)) < epslion for all 1 <= x < window_size is equilibrium,
+          # and we return that time point.
+          proportion_over_time[start_index..-1].each_cons(window_size).find do |proportion_slice|
+            proportion_slice.all? { |time, proportion| (proportion - proportion_slice.first.last).abs < epsilon }
+          end.first.first
+        end
+
+        def time_points; proportion_over_time.map(&:first); end
+        def proportion_points; proportion_over_time.map(&:last); end
+
+        def each
+          proportion_over_time.each { |_| yield _ }
+        end
+
+        def inspect
+          "#<Wrnap::Package::Population::PopulationProportion time: (%f..%f), proportion: (%f..%f)>" % [
+            time_points[0],
+            time_points[-1],
+            proportion_points[0],
+            proportion_points[-1],
+          ]
+        end
+      end
+
+      def run_command(flags)
+        Wrnap.debugger { "Running #{exec_name} on #{data.inspect}" }
+
+        "%s %s" % [exec_name, stringify_flags(flags)]
+      end
+
+      def post_process
+        time_points, str_1_to_str_2, str_1_to_str_1 = response.split(/\n/).select { |line| line =~ THREE_COLUMN_REGEX }.map { |line| line.split(/\t/).map(&:to_f) }.transpose
+        @str_1_to_str_2 = PopulationProportion.new(time_points, str_1_to_str_2)
+        @str_1_to_str_1 = PopulationProportion.new(time_points, str_1_to_str_1)
+      end
+    end
+  end
+end

data/lib/wrnap/package/rna2dfold.rb

@@ -0,0 +1,27 @@
+module Wrnap
+  module Package
+    class Rna2dfold < EnergyGrid2d
+      self.default_flags = {
+        d:         0,
+        p:         true,
+        "-noBT" => true
+      }
+
+      self.executable_name = "RNA2Dfold"
+
+      def run_command(flags)
+        Wrnap.debugger { "Running RNA2Dfold on #{data.inspect}" }
+      
+        "cat %s | %s %s" % [
+          data.temp_fa_file!,
+          exec_name, 
+          stringify_flags(flags)
+        ]
+      end
+    
+      def distribution
+        response.split(/\n/)[6..-1].map { |line| line.split(/\t/).at_indexes([0, 1, 2, 6]) }
+      end
+    end
+  end
+end

data/lib/wrnap/package/rnabor.rb

@@ -0,0 +1,32 @@
+module Wrnap
+  module Package
+    class Rnabor < Xbor
+      FLAGS = {
+        nodangle: :empty
+      }
+    
+      def partition
+        non_zero_shells.inject(&:+)
+      end
+    
+      def total_count
+        counts.inject(&:+)
+      end
+    
+      def counts
+        (non_zero_counts = self.class.parse(response).map { |row| BigDecimal.new(row[2]).to_i }) + [0] * (data.seq.length - non_zero_counts.length + 1)
+      end
+    
+      def distribution(options = {})
+        options = { precision: 4 }.merge(options)
+      
+        distribution_before_precision = (non_zero_distribution = non_zero_shells.map { |i| i / partition }) + [0.0] * (data.seq.length - non_zero_distribution.length + 1)
+        distribution_before_precision.map { |value| options[:precision].zero? ? value : (value * 10 ** options[:precision]).truncate / 10.0 ** options[:precision] }
+      end
+    
+      def non_zero_shells
+        self.class.parse(response).map { |row| BigDecimal.new(row[1]) }
+      end
+    end
+  end
+end

data/lib/wrnap/package/spectral.rb

@@ -0,0 +1,24 @@
+module Wrnap
+  module Package
+    class Spectral < Base      
+      self.default_flags = ->(context, flags) { { seq: context.data.seq, step_size: "1e-2" } }
+      
+      attr_reader :eigenvalues, :time_kinetics
+    
+      def run_command(flags)
+        "%s %s" % [
+          exec_name, 
+          stringify_flags(flags)
+        ]
+      end
+    
+      def post_process
+        if flags.keys.include?(:eigen_only)
+          @eigenvalues = response.split(?\n).map(&:to_f).sort_by(&:abs)
+        else
+          @time_kinetics = response.split(?\n).map { |line| line.split(?\t).map(&:to_f) }
+        end
+      end
+    end
+  end
+end

data/lib/wrnap/package/subopt.rb

@@ -0,0 +1,26 @@
+module Wrnap
+  module Package
+    class Subopt < Base
+      attr_reader :structures
+
+      def post_process
+        @structures = response.split(/\n/)[1..-1].map do |output|
+          structure, mfe = output.split(/\s+/)
+
+          RNA.from_string(data.seq, structure).tap do |rna|
+            rna.instance_variable_set(:@mfe, mfe.to_f)
+            rna.class_eval { attr_reader :mfe }
+          end
+        end
+      end
+
+      def bin(count = 1)
+        run(p: count).structures.inject(Hash.new { |hash, key| hash[key] = 0 }) do |hash, structure|
+          hash.tap do
+            hash[structure] += 1
+          end
+        end
+      end
+    end
+  end
+end

data/lib/wrnap/package/tabu_path.rb

@@ -0,0 +1,50 @@
+module Wrnap
+  module Package
+    class TabuPath < Base
+      self.executable_name = "get_barrier_tabu"
+      self.default_flags   = ->(context, flags) { { iterations: 10, min_weight: 10, max_weight: 70 } }
+      
+      attr_reader :paths
+    
+      def run_command(flags)
+        Wrnap.debugger { "Running #{exec_name} on #{data.inspect}" }
+      
+        [
+          exec_name, 
+          data.seq.inspect,
+          data.str_1.inspect,
+          data.str_2.inspect,
+          flags[:iterations],
+          flags[:min_weight],
+          flags[:max_weight]
+        ].join(" ")
+      end
+    
+      def post_process
+        @paths = response.split(data.str_1 + ?\n).reject(&:empty?).map { |path_string| Path.new(data, path_string) }
+      end
+      
+      class Path
+        attr_reader :rna, :path, :barrier, :best_weight
+        
+        def initialize(rna, output)
+          @rna                      = rna
+          @path                     = output.split(?\n)[0..-2].unshift(rna.str_1)
+          @barrier, _, @best_weight = output.split(?\n)[-1].gsub(/[^\d\.]/, " ").strip.split(/\s+/).map(&:to_f)
+        end
+        
+        def length
+          path.length
+        end
+        
+        def full_path?
+          rna.str_1 == path.first && rna.str_2 == path.last
+        end
+        
+        def inspect
+          "#<#{self.class.name} with barrier %.2f and length %d on #{rna.inspect}>" % [barrier, best_weight]
+        end
+      end
+    end
+  end
+end

data/lib/wrnap/package/xbor.rb

@@ -0,0 +1,63 @@
+module Wrnap
+  module Package
+    class Xbor < Base
+      self.default_flags = {
+        E: "/usr/local/bin/rna_turner2004.par"
+      }
+    
+      self.executable_name = ->(context) { context.class.name.demodulize.gsub(/^([A-Z].*)bor$/) { |match| $1.upcase + "bor" } }
+    
+      def run_command(flags)
+        file = Tempfile.new("rna")
+        file.write("%s\n" % data.seq)
+        file.write("%s\n" % data.str)
+        file.close
+      
+        Wrnap.debugger { "Running FFTbor on #{data.inspect}" }
+      
+        "%s %s %s" % [
+          exec_name, 
+          stringify_flags(flags), 
+          file.path
+        ]
+      end
+    
+      def self.parse(response)
+        response.split(/\n/).select { |line| line =~ /^\d+\t-?\d+/ }.map { |line| line.split(/\t/) }
+      end
+    
+      def full_distribution
+        distribution      = run.distribution
+        full_distribution = distribution + ([0.0] * ((differnece = data.seq.length - distribution.length + 1) < 0 ? 0 : differnece))
+      end
+    
+      def k_p_points
+        full_distribution.each_with_index.to_a.map(&:reverse)[0..data.seq.length]
+      end
+    
+      def expected_k
+        k_p_points.map { |array| array.inject(&:*) }.inject(&:+)
+      end
+      
+      def to_csv
+        k_p_points.map { |k, p| "%d,%.8f" % [k, p] }.join(?\n) + ?\n
+      end
+      
+      def to_csv!(filename)
+        File.open(filename, ?w) { |file| file.write(to_csv) }
+      end
+    
+      def quick_plot(filename: false)
+        Wrnap::Graphing::R.line_graph(
+          k_p_points,
+          title:    options[:title] || "%s\\n%s\\n%s" % [self.class.name, data.seq, data.safe_structure],
+          filename: false
+        )
+      end
+    
+      def inspect
+        "#<#{self.class.name} #{data.inspect}>"
+      end
+    end
+  end
+end

data/lib/wrnap/version.rb

@@ -0,0 +1,3 @@
+module Wrnap
+  VERSION = "0.0.1"
+end

data/lib/wrnap.rb

@@ -0,0 +1,80 @@
+require "benchmark"
+require "set"
+require "shuffle"
+require "rinruby"
+require "tempfile"
+require "bigdecimal"
+require "rroc"
+require "active_support/inflector"
+require "active_support/core_ext/class"
+
+require "wrnap/version"
+require "wrnap/global/rna_extensions"
+require "wrnap/global/rna"
+require "wrnap/global/parser"
+require "wrnap/global/run_extensions"
+require "wrnap/global/chain_extensions"
+require "wrnap/graphing/r"
+require "wrnap/package/base"
+
+begin; R.quit; rescue IOError; end
+
+module Wrnap
+  RT     = 1e-3 * 1.9872041 * (273.15 + 37) # kcal / K / mol @ 37C
+  @debug = true
+
+  module Package
+    Dir[File.join(File.dirname(__FILE__), "wrnap", "package", "*.rb")].reject { |file| file =~ /\/base.rb/ }.each do |file|
+      autoload(File.basename(file, ".rb").camelize.to_sym, "wrnap/package/#{File.basename(file, '.rb')}")
+    end
+
+    def self.const_missing(name)
+      if const_defined?(name)
+        const_get(name)
+      elsif Base.exec_exists?(name)
+        module_eval do
+          const_set(name, Class.new(Base))
+        end
+      end
+    end
+  end
+
+  def self.deserialize(string)
+    YAML.load(File.exist?(string) ? File.read(string) : string)
+  end
+
+  def self.debugger
+    STDERR.puts yield if Wrnap.debug
+  end
+
+  def self.debug
+    @debug
+  end
+
+  def self.debug=(value)
+    @debug = value
+  end
+end
+
+# This dirties up the public namespace, but I use it so many times that I want a shorthand to it
+unless defined? RNA
+  def RNA(*args)
+    RNA.from_array(args)
+  end
+end
+
+module RNA
+  def self.load_all(pattern = "*.fa")
+    Dir[File.directory?(pattern) ? pattern + "/*.fa" : pattern].map { |file| RNA.from_fasta(file) }
+  end
+
+  def self.random(size, *args)
+    RNA.from_array(args.unshift(Wrnap::Global::Rna.generate_sequence(size).seq))
+  end
+
+  def self.method_missing(name, *args, &block)
+    if "#{name}" =~ /^from_\w+$/
+      Wrnap::Global::Rna.send("init_#{name}", *args)
+    else super end
+  end
+end

data/wrnap.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'wrnap/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "wrnap"
+  spec.version       = Wrnap::VERSION
+  spec.authors       = ["Evan Senter"]
+  spec.email         = ["evansenter@gmail.com"]
+  spec.summary       = %q{A comprehensive wrapper (wRNApper) for various RNA CLI programs.}
+  spec.description   = %q{}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+
+  spec.add_runtime_dependency "activesupport", "~> 4.0"
+  spec.add_runtime_dependency "shuffle",       "~> 0.1"
+  spec.add_runtime_dependency "rinruby",       "~> 2.0"
+  spec.add_runtime_dependency "rroc",          "~> 0.1"
+end

metadata

@@ -0,0 +1,162 @@
+--- !ruby/object:Gem::Specification
+name: wrnap
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Evan Senter
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: shuffle
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: rinruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rroc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+description: ''
+email:
+- evansenter@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.md
+- README.md
+- Rakefile
+- lib/wrnap.rb
+- lib/wrnap/global/chain_extensions.rb
+- lib/wrnap/global/parser.rb
+- lib/wrnap/global/rna.rb
+- lib/wrnap/global/rna_extensions.rb
+- lib/wrnap/global/run_extensions.rb
+- lib/wrnap/graphing/r.rb
+- lib/wrnap/package/base.rb
+- lib/wrnap/package/energy_grid_2d.rb
+- lib/wrnap/package/eval.rb
+- lib/wrnap/package/fft_mfpt.rb
+- lib/wrnap/package/fftbor.rb
+- lib/wrnap/package/fftbor2d.rb
+- lib/wrnap/package/ffthairpin.rb
+- lib/wrnap/package/fftmultiloop.rb
+- lib/wrnap/package/fold.rb
+- lib/wrnap/package/heat.rb
+- lib/wrnap/package/kinwalker.rb
+- lib/wrnap/package/mfpt.rb
+- lib/wrnap/package/plot.rb
+- lib/wrnap/package/population.rb
+- lib/wrnap/package/rna2dfold.rb
+- lib/wrnap/package/rnabor.rb
+- lib/wrnap/package/spectral.rb
+- lib/wrnap/package/subopt.rb
+- lib/wrnap/package/tabu_path.rb
+- lib/wrnap/package/xbor.rb
+- lib/wrnap/version.rb
+- wrnap.gemspec
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: A comprehensive wrapper (wRNApper) for various RNA CLI programs.
+test_files: []