bioroebe 0.10.80

data/lib/bioroebe/toplevel_methods/hamming_distance.rb

@@ -0,0 +1,60 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'bioroebe/toplevel_methods/hamming_distance.rb'
+# Bioroebe.hamming_distance('ATCG','ATCC')
+# puts Bioroebe.hamming_distance(ARGV[0], ARGV[1])
+# =========================================================================== #
+module Bioroebe
+
+  # ========================================================================= #
+  # === Bioroebe.hamming_distance
+  #
+  # This method will return an Integer, aka a number, which represents
+  # the hamming distance between two sequences of equal length. This
+  # will state how many differences exist between two same-sized
+  # sequences (aka sequences that have the same length).
+  #
+  # Do note that a second implementation may exist for the hamming
+  # distance, in the Bioroebe project.
+  #
+  # Usage example:
+  #
+  #   Bioroebe.hamming_distance('ATCG','ATCC') # => 1
+  #
+  # ========================================================================= #
+  def self.hamming_distance(
+      sequence1 = 'ATCG',
+      sequence2 = 'ATCC'
+    )
+    if sequence1.nil?
+      e 'Please provide a sequence (String) as input to this method.'
+      return
+    end
+    if sequence1.is_a? String
+      sequence1 = sequence1.split(//)
+    end
+    if sequence2.is_a? String
+      sequence2 = sequence2.split(//)
+    end
+    array_sequence1 = [sequence1].flatten
+    array_sequence2 = [sequence2].flatten
+    # ======================================================================= #
+    # Zip the two sequences together, then reduce this Array of
+    # zipped values to an integer value, which will be returned.
+    # ======================================================================= #
+    zipped_array = array_sequence1.zip(array_sequence2)
+    hamming_value = 0
+    zipped_array.each { |left, right|
+      hamming_value += 1 unless left == right
+    }
+    return hamming_value
+  end; self.instance_eval { alias hamming hamming_distance } # === Bioroebe.hamming
+
+end
+
+if __FILE__ == $PROGRAM_NAME
+  puts Bioroebe.hamming_distance(ARGV[0], ARGV[1])
+end # hammingdistancemodulemethod GAGCCTACTAACGGGAT CATCGTAATGACGGCCT
+    # hammingdistancemodulemethod ATC ATT

data/lib/bioroebe/toplevel_methods/infer.rb

@@ -0,0 +1,66 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# This file may contain code that can be used to "infer" something.
+#
+# The primary use case is to infer whether a given sequence is DNA,
+# RNA or an aminoacid sequence.
+# =========================================================================== #
+# require 'bioroebe/toplevel_methods/infer.rb'
+# Bioroebe.infer_type_from_this_sequence
+# =========================================================================== #
+module Bioroebe
+
+  # ========================================================================= #
+  # === Bioroebe.infer_type_from_this_sequence
+  #
+  # This method will try to infer the type from a given sequence.
+  #
+  # The three valid return types are the following symbols:
+  #
+  #   :dna
+  #   :rna
+  #   :protein
+  #
+  # Note that this may not work 100% reliably, so do not depend too
+  # much on this method working absolutely perfect.
+  # ========================================================================= # 
+  def self.infer_type_from_this_sequence(
+      i = 'ATGGTACGACAC'
+    )
+    if i.is_a? Array
+      i = i.join
+    end
+    type = :dna # This is the default - DNA.
+    # ======================================================================= #
+    # === :rna
+    # ======================================================================= #
+    if i.include? 'U'
+      type = :rna
+    # ======================================================================= #
+    # === :dna
+    # ======================================================================= #
+    elsif i =~ /^[ATCG]+$/
+      type = :dna 
+    # ======================================================================= #
+    # === :protein
+    # ======================================================================= #
+    else # else simply assume this to be a protein.
+      type = :protein
+    end
+    return type
+  end; self.instance_eval { alias infer_the_type_from_this_sequence infer_type_from_this_sequence } # === Bioroebe.infer_the_type_from_this_sequence
+
+end
+
+if __FILE__ == $PROGRAM_NAME
+  if ARGV.empty?
+    # In this case test this.
+    pp Bioroebe.infer_type_from_this_sequence('ATCGATCATTCGATGCAGTCA')   # => :dna
+    pp Bioroebe.infer_type_from_this_sequence('UCAGUCAGUCAGUCAGUACGUCA') # => :rna
+    pp Bioroebe.infer_type_from_this_sequence('ATGGGVVVIIILLP')          # => :protein
+  else
+    pp Bioroebe.infer_type_from_this_sequence(ARGV)
+  end
+end # rb infer.rb ATCAGCTAGCATCA

data/lib/bioroebe/toplevel_methods/is_on_roebe.rb

@@ -0,0 +1,39 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# This file handles the situation when I am on my home system. On my home
+# system, I tend to have a variable called IS_ROEBE set to 1. In this
+# case, some checks done by the Bioroebe project will return true, which
+# is used in some parts of the scripts to e. g. yield more information
+# about certain parts of the code.
+# =========================================================================== #
+# require 'bioroebe/toplevel_methods/is_on_roebe.rb'
+# =========================================================================== #
+module Bioroebe
+
+  # ========================================================================= #
+  # === Bioroebe.is_on_roebe?
+  # ========================================================================= #
+  def self.is_on_roebe?
+    ENV['IS_ROEBE'] == '1' # This is the case on my home system.
+  end; self.instance_eval { alias roebe?    is_on_roebe? } # === Bioroebe.roebe?
+       self.instance_eval { alias on_roebe? is_on_roebe? } # === Bioroebe.on_roebe?
+       self.instance_eval { alias is_roebe? is_on_roebe? } # === Bioroebe.is_roebe?
+
+  # ========================================================================= #
+  # === on_roebe?
+  #
+  # Whether I am at home or whether I am not.
+  # ========================================================================= #
+  def is_on_roebe?
+    Bioroebe.is_on_roebe?
+  end; alias roebe?    is_on_roebe? # === roebe?
+       alias on_roebe? is_on_roebe? # === on_roebe?
+       alias is_roebe? is_on_roebe? # === is_roebe?
+
+end
+
+if __FILE__ == $PROGRAM_NAME
+  puts Bioroebe.is_on_roebe?
+end

data/lib/bioroebe/toplevel_methods/leading_five_prime_and_trailing_three_prime.rb

@@ -0,0 +1,101 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'bioroebe/toplevel_methods/leading_five_prime_and_trailing_three_prime.rb'
+# Bioroebe.leading_five_prime(ARGV)
+# Bioroebe.trailing_three_prime(ARGV)
+# =========================================================================== #
+module Bioroebe
+
+  # ========================================================================= #
+  # === Bioroebe.leading_five_prime
+  #
+  # This method will output the leading 5' part of a nucleotide sequence,
+  # like a header. In this context, the most commonly usage case for
+  # this method is to display a leading "5'-" part to a sequence such
+  # as "ATCGATCG".
+  #
+  # The hyphen refers to the '-' character which may be used by this
+  # method. This is optional, though - have a look at the third
+  # argument to this method called `use_hyphen?.
+  # ========================================================================= #
+  def self.leading_five_prime(
+      i                 = '', # The default to '' is important.
+      get_rid_of_spaces = false,
+      use_hyphen        = true # By default this method will use '-' characters.
+    )
+    case get_rid_of_spaces
+    # ======================================================================= #
+    # === :no_spaces
+    # ======================================================================= #
+    when :no_spaces,
+         :get_rid_of_spaces
+      get_rid_of_spaces = true
+    end
+    if i.is_a? Array
+      i = i.join.strip
+    end
+    if use_hyphen
+      _ = "5' - #{i}" # ← This here is the header-tag.
+    else # This variant is a bit simpler and shorter.
+      _ = "5' #{i}" # ← This here is the header-tag.
+    end
+    if get_rid_of_spaces
+      _ = _.dup if _.frozen?
+      _.delete!(' ')
+    end
+    return _
+  end; self.instance_eval { alias five_prime               leading_five_prime } # === Bioroebe.five_prime
+       self.instance_eval { alias leading_5_prime          leading_five_prime } # === Bioroebe.leading_five_prime
+       self.instance_eval { alias leader                   leading_five_prime } # === Bioroebe.leader
+       self.instance_eval { alias lead_five_prime          leading_five_prime } # === Bioroebe.lead_five_prime
+       self.instance_eval { alias return_five_prime_header leading_five_prime } # === Bioroebe.return_five_prime
+       self.instance_eval { alias leading_five             leading_five_prime } # === Bioroebe.return_five
+
+  # ========================================================================= #
+  # === Bioroebe.trailing_three_prime
+  #
+  # This method will output the trailing 3' part, like a header (or rather,
+  # a trailer).
+  # ========================================================================= #
+  def self.trailing_three_prime(
+      i                 = '', # The default to '' is important.
+      get_rid_of_spaces = false,
+      use_hyphen        = true
+    )
+    case get_rid_of_spaces
+    # ======================================================================= #
+    # === :no_spaces
+    # ======================================================================= #
+    when :no_spaces,
+         :get_rid_of_spaces,
+         :eliminate_spaces
+      get_rid_of_spaces = true
+    end
+    if i.is_a? Array
+      i = i.join.strip
+    end
+    if use_hyphen
+      _ = "#{i} - 3'" # ← This here is the header-tag.
+    else # This variant is a bit simpler and shorter.
+      _ = "#{i} 3'"   # ← This here is the header-tag.
+    end
+    _.delete!(' ') if get_rid_of_spaces
+    return _
+  end; self.instance_eval { alias three_prime               trailing_three_prime } # === Bioroebe.three_prime
+       self.instance_eval { alias trailing_3_prime          trailing_three_prime } # === Bioroebe.trailing_three_prime
+       self.instance_eval { alias leader                    trailing_three_prime } # === Bioroebe.leader
+       self.instance_eval { alias lead_three_prime          trailing_three_prime } # === Bioroebe.lead_three_prime
+       self.instance_eval { alias return_three_prime_header trailing_three_prime } # === Bioroebe.return_three_prime
+       self.instance_eval { alias trailing_three            trailing_three_prime } # === Bioroebe.return_three
+
+end
+
+if __FILE__ == $PROGRAM_NAME
+  puts Bioroebe.leading_five_prime(ARGV)
+  puts Bioroebe.trailing_three_prime(ARGV)
+  puts Bioroebe.leading_five_prime(ARGV, :eliminate_spaces)
+  puts Bioroebe.trailing_three_prime(ARGV, :eliminate_spaces)
+end # leadingfiveprime   ATGCT
+    # trailingthreeprime ATGCT

data/lib/bioroebe/toplevel_methods/levensthein.rb

@@ -0,0 +1,63 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+module Bioroebe
+
+  # ========================================================================= #
+  # === Bioroebe.min3
+  # ========================================================================= #
+  def self.min3(a, b, c)
+    if a < b && a < c
+      a
+    elsif b < c
+      b
+    else
+      c
+    end
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.levenshtein_distance
+  # ========================================================================= #
+  def self.levenshtein_distance(str1, str2)
+    n = str1.length
+    m = str2.length
+
+    return m if n.zero?
+    return n if m.zero?
+
+    x = nil
+    d = (0 .. m).to_a # Get the distance.
+
+    # ======================================================================= #
+    # To avoid duplicating an enumerable object, create it outside of the
+    # loop.
+    # ======================================================================= #
+    str2_codepoints = str2.codepoints
+
+    str1.each_codepoint.with_index(1) { |char1, i|
+      j = 0
+      while j < m
+        cost = (char1 == str2_codepoints[j]) ? 0 : 1
+        x = min3(
+          d[j + 1] + 1, # insertion
+          i + 1,        # deletion
+          d[j] + cost   # substitution
+        )
+        d[j] = i
+        i = x
+        j += 1
+      end
+      d[m] = x
+    }
+    x # Return the cost here.
+  end
+
+end
+
+if __FILE__ == $PROGRAM_NAME
+  alias e puts
+  e 'Difference between "shevy" and "chevy" is: '+
+     Bioroebe.levenshtein_distance('shevy', 'chevy').to_s # => 1  
+end # rb levensthein.rb

data/lib/bioroebe/toplevel_methods/log_directory.rb

@@ -0,0 +1,109 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# This file keeps track of where we will store output generated by
+# the Bioroebe project.
+# =========================================================================== #
+# require 'bioroebe/toplevel_methods/log_directory.rb'
+# Bioroebe.download_dir?
+# =========================================================================== #
+module Bioroebe
+
+  # ========================================================================= #
+  # === @log_directory
+  #
+  # Keep track where to log output into, through this variable.
+  # ========================================================================= #
+  @log_directory = nil
+
+  # ========================================================================= #
+  # === Bioroebe.log_directory?
+  #
+  # This method will keep track over where we will store output,
+  # related to the Bioroebe project.
+  # ========================================================================= #
+  def self.log_directory?
+    @log_directory
+  end; self.instance_eval { alias log_dir                log_directory? } # === Bioroebe.log_dir
+       self.instance_eval { alias store_here?            log_directory? } # === Bioroebe.store_here?
+       self.instance_eval { alias save_dir?              log_directory? } # === Bioroebe.save_dir?
+       self.instance_eval { alias log_dir?               log_directory? } # === Bioroebe.log_dir?
+       self.instance_eval { alias project_log_directory? log_directory? } # === Bioroebe.project_log_directory?
+
+  require 'bioroebe/constants/base_directory.rb'
+  # ========================================================================= #
+  # === Bioroebe.set_log_dir
+  #
+  # This method will set the log-directory for the Bioroebe project.
+  #
+  # Usually this will be in the user's home directory, and then a
+  # 'Bioroebe/' suffix appended. The default input-value is the
+  # symbol :default.
+  #
+  # The user can set to use another log-directory through this method.
+  # ========================================================================= #
+  def self.set_log_directory(
+      i = :default
+    )
+    case i # case tag
+    # ======================================================================= #
+    # === :default
+    #
+    # This is the default value.
+    # ======================================================================= #
+    when :default
+      i = ::Bioroebe.base_directory?
+    end
+    unless i.end_with? '/'
+      i = i.dup if i.frozen?
+      i << '/'
+    end
+    @log_directory = i
+  end; self.instance_eval { alias set_log_dir set_log_directory } # === Bioroebe.set_log_dir
+
+  # ========================================================================= #
+  # === Initialize it at once, with the default value.
+  # ========================================================================= #
+  _ = :default # Uses the default path.
+  if ENV.has_key? 'BIOROEBE_DEFAULT_LOG_DIRECTORY'
+    _ = ENV['BIOROEBE_DEFAULT_LOG_DIRECTORY']
+  end
+  set_log_directory(_)
+
+  # ========================================================================= #
+  # === Bioroebe.download_directory?
+  # ========================================================================= #
+  def self.download_directory?
+    "#{@log_directory}Downloads/"
+  end; self.instance_eval { alias download_dir? download_directory? } # === Bioroebe.download_dir?
+
+  # ========================================================================= #
+  # === LOCAL_DIRECTORY_FOR_UNIPROT
+  #
+  # This denotes the directory for uniprot-files.
+  # ========================================================================= #
+  LOCAL_DIRECTORY_FOR_UNIPROT = "#{@log_directory}uniprot/"
+
+  # ========================================================================= #
+  # === Bioroebe::AUTOGENERATED_SQL_FILES_DIR
+  # ========================================================================= #
+  AUTOGENERATED_SQL_FILES_DIR =
+    "#{@log_directory}autogenerated_sql_files/" # Where to store .sql files.
+
+  # ========================================================================= #
+  # === Bioroebe.fasta_directory?
+  #
+  # This method will return a path such as "/root/Bioroebe/fasta/".
+  # ========================================================================= #
+  def self.fasta_directory?
+    "#{::Bioroebe.log_directory?}fasta/"
+  end
+
+end
+
+if __FILE__ == $PROGRAM_NAME
+  alias e puts
+  e Bioroebe.log_directory?
+  e Bioroebe.download_directory?  
+end

data/lib/bioroebe/toplevel_methods/longest_common_substring.rb

@@ -0,0 +1,55 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'bioroebe/toplevel_methods/longest_common_substring.rb'
+# =========================================================================== #
+module Bioroebe
+
+  # ========================================================================= #
+  # === Bioroebe.longest_common_substring
+  #
+  # This method will return the longest common substring. There may be
+  # more than one solution, though.
+  #
+  # Note that this method was specifically written for Rosalind, so it
+  # may not be too overly useful for most general tasks. For example,
+  # it is not optimised for speed, so you should probably not use
+  # it for very long sequences.
+  # ========================================================================= #
+  def self.longest_common_substring(sequences)
+    if sequences and !sequences.empty? and File.file?(sequences.first)
+      require 'bioroebe/requires/require_all_fasta_and_fastq_files.rb'
+      hash = parse_fasta_quietly(sequences.first).hash?
+      sequences = hash.values.map {|entry| entry.delete("\n") }
+    end
+    # ======================================================================= #
+    # First obtain a handle towards the shortest sequence.
+    # ======================================================================= #
+    shortest_sequence = sequences.min_by(&:length)
+    maxlen = shortest_sequence.length
+    maxlen.downto(1) {|len|
+      0.upto(maxlen - len) { |start|
+        substring = shortest_sequence.to_s[start,len]
+        if sequences.all? {|seq| seq.to_s.include? substring }
+          return shortest_sequence.class.new(substring)
+        end
+      }
+    }
+    return nil
+  end
+
+end
+
+if __FILE__ == $PROGRAM_NAME
+  alias e puts
+  if ARGV.empty?
+    e Bioroebe.longest_common_substring(
+      %w( GATTACA TAGACCA ATACA )
+    )
+  else
+    e Bioroebe.longest_common_substring(ARGV)
+  end
+end # longestcommonsubstring
+    # longestcommonsubstring ATTTTT ATTT
+    # longestcommonsubstring /rosalind_lcsm.txt

data/lib/bioroebe/toplevel_methods/map_ncbi_entry_to_eutils_id.rb

@@ -0,0 +1,88 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'bioroebe/toplevel_methods/map_ncbi_entry_to_eutils_id.rb'
+# =========================================================================== #
+module Bioroebe
+
+  # ========================================================================= #
+  # === Bioroebe.map_ncbi_entry_to_eutils_id
+  #
+  # This is a general "URL mapper" from certain NCBI IDs to specific
+  # nucleotide sequences. Only some URLs will be mapped, in particular
+  # those that I use more frequently.
+  #
+  # The method was created specifically to allow simpler input via
+  # the commandline and the bioshell - it is easier to remember
+  # a name such as "rhinovirus" as opposed to the NC entry, which
+  # is "NC_038311".
+  #
+  # Usage examples:
+  #
+  #   Bioroebe.map_ncbi_entry_to_eutils_id 'rhinovirus'
+  #   Bioroebe.map_ncbi_entry_to_eutils_id 'T6'
+  # 
+  # ========================================================================= #
+  def self.map_ncbi_entry_to_eutils_id(
+      i = 'NC_001416.1.fasta'
+    )
+    case i
+    # ======================================================================= #
+    # === Lambda phage genome
+    # ======================================================================= #
+    when /^-?-?NC_001416.1.fasta$/i,
+         'lambda'
+      i = '9626243'
+    # ======================================================================= #
+    # === P1
+    # ======================================================================= #
+    when 'NC_005856.1.fasta',
+         'P1'
+      i = '46401626'
+    # ======================================================================= #
+    # === P2
+    # ======================================================================= #
+    when 'NC_041848.1.fasta',
+         'P2'
+      i = '1631913463'
+    # ======================================================================= #
+    # === T12
+    # ======================================================================= #
+    when 'NC_028700.1.fasta',
+         'T12'
+      i = '966201481'
+    # ======================================================================= #
+    # === T2
+    # ======================================================================= #
+    when 'AP018813.1.fasta',
+         'T2'
+      i = 'AP018813.1'
+    # ======================================================================= #
+    # === T4
+    # ======================================================================= #
+    when 'NC_000866.4.fasta',
+         'T4'
+      i = 'NC_000866.4'
+    # ======================================================================= #
+    # === T6
+    # ======================================================================= #
+    when 'T6'
+      i = 'MH550421.1'
+    # ======================================================================= #
+    # === rhinovirus
+    # ======================================================================= #
+    when /NC_038311/,
+         'rhinovirus'
+      i = '1464306962'
+    end
+    return i
+  end
+
+end
+
+if __FILE__ == $PROGRAM_NAME
+  alias e puts
+  e Bioroebe.map_ncbi_entry_to_eutils_id 'rhinovirus'
+  e Bioroebe.map_ncbi_entry_to_eutils_id 'T6'
+end