bioroebe 0.10.80 → 0.12.24

data/lib/bioroebe/python/toplevel_methods/three_delimiter.py

@@ -0,0 +1,37 @@
+#!/usr/bin/python3
+# =========================================================================== #
+import sys
+import re
+
+class Bioroebe(object):
+
+  # ========================================================================= #
+  # === Bioroebe.three_delimiter
+  #
+  # This method will, applied onto a String, add the '|' token
+  # after 3 positions.
+  #
+  # Example: 
+  #
+  #    Bioroebe.three_delimiter('ATGGGGATGTAGGTA') # => "ATG|GGG|ATG|TAG|GTA"
+  #
+  # ========================================================================= #
+  def three_delimiter(i):
+
+    if isinstance(i, list):
+      i = ' '.join(str(e) for e in i)
+
+    i = re.sub(r'(...)', r'\1-', i)
+
+    if i[-1] == '-': # Chop of the last character if it is a '-' token.
+      i = i[:-1]
+
+    return i 
+
+if __name__ == '__main__':
+  if len(sys.argv) > 1:
+    i = sys.argv[1]
+    print(Bioroebe.three_delimiter(i))
+  else:
+    print("Please provide an argument to this method.")
+# py three_delimiter.py ATGGGGATGTAGGTA

data/lib/bioroebe/python/toplevel_methods/time_and_date.py

@@ -0,0 +1,43 @@
+#!/usr/bin/python3
+import sys
+from datetime import datetime
+
+class Bioroebe(object):
+
+  # ========================================================================= #
+  # === Bioroebe.return_current_day_month_year()
+  #
+  # This method will return a String such as "09.07.2022".
+  # ========================================================================= #
+  def return_current_day_month_year():
+    day   = str(datetime.now().day).rjust(2, '0')
+    month = str(datetime.now().month).rjust(2, '0')
+    year  = str(datetime.now().year)
+    return day+'.'+month+'.'+year
+
+  # ========================================================================= #
+  # === Bioroebe.return_current_hours_minutes_seconds()
+  #
+  # This method will return a String such as "20:44:20".
+  # ========================================================================= #
+  def return_current_hours_minutes_seconds():
+    hours   = str(datetime.now().hour).rjust(2, '0')
+    minutes = str(datetime.now().minute).rjust(2, '0')
+    seconds = str(datetime.now().second).rjust(2, '0')
+    return hours+':'+minutes+':'+seconds
+
+  # ========================================================================= #
+  # === Bioroebe.show_time_now
+  #
+  # This method will show the current time. It will do so only if the
+  # verbosity-variable has been set to true.
+  # ========================================================================= #
+  def show_time_now(be_verbose = True):
+    time = Bioroebe.return_current_hours_minutes_seconds()
+    if be_verbose:
+      print("Showing the current time: "+time)
+
+if __name__ == '__main__':
+  print(Bioroebe.return_current_day_month_year())
+  print(Bioroebe.return_current_hours_minutes_seconds())
+  Bioroebe.show_time_now()

data/lib/bioroebe/python/toplevel_methods/to_camelcase.py

@@ -0,0 +1,21 @@
+from re import sub
+import sys
+
+# =========================================================================== #
+# === camel_case
+# =========================================================================== #
+def camel_case(i):
+  i = sub(r"(_|-)+", " ", i).title().replace(" ", "")
+  return ''.join(
+    [
+      i[0].upper(),
+      i[1:]
+    ]
+  )
+
+if __name__ == "__main__":
+  print(
+    camel_case(
+      sys.argv[1]
+    )
+  ) # py to_camelcase.py abcDef

data/lib/bioroebe/requires/require_cleave_and_digest.rb

@@ -11,7 +11,9 @@ module Bioroebe
   # ========================================================================= #
   # === Bioroebe.require_all_cleave_and_digest_files
   # ========================================================================= #
-  def self.require_all_cleave_and_digest_files(i = CLEAVE_AND_DIGEST_DIRECTORY)
+  def self.require_all_cleave_and_digest_files(
+      i = CLEAVE_AND_DIGEST_DIRECTORY
+    )
     _ = Dir["#{i}*.rb"]
     _.each {|file|
       file = "bioroebe/cleave_and_digest/#{File.basename(file)}"

data/lib/bioroebe/requires/require_the_bioroebe_project.rb

@@ -159,4 +159,6 @@ require 'bioroebe/requires/require_all_codon_files.rb'
 # And the sinatra-interface:
 # =========================================================================== #
 # require 'bioroebe/requires/require_the_bioroebe_sinatra_components.rb'
-require 'bioroebe/www/sinatra/sinatra.rb'
+require 'bioroebe/www/sinatra/sinatra.rb'
+
+require 'bioroebe/sequence/protein.rb'

data/lib/bioroebe/sequence/alignment.rb

@@ -28,6 +28,8 @@ module Bioroebe
 
 class Alignment < ::Bioroebe::CommandlineApplication # === Bioroebe::Alignment
 
+  require 'bioroebe/misc/ruler.rb'
+
   # ========================================================================= #
   # === initialize
   # ========================================================================= #
@@ -122,9 +124,12 @@ class Alignment < ::Bioroebe::CommandlineApplication # === Bioroebe::Alignment
   # ========================================================================= #
   def print_consensus_sequence
     e
-    erev 'The consensus sequence, derived from the above matrix, is:'
+    n_nucleotides = @array_G.size
+    erev 'The consensus sequence ('+steelblue(n_nucleotides.to_s)+
+         rev+' nucleotides), '\
+         'derived from the above matrix, is:'
     e
-    print '  '
+    sequence_that_will_be_displayed = ''.dup
     @array_G.size.times {|index|
       hash = {}
       hash['A'] = @array_A[index]
@@ -132,8 +137,12 @@ class Alignment < ::Bioroebe::CommandlineApplication # === Bioroebe::Alignment
       hash['C'] = @array_C[index]
       hash['G'] = @array_G[index]
       _ = hash.max_by {|key, value| value }
-      print mediumslateblue(_[0])+rev # Print each individual character here.
+      sequence = _[0]
+      sequence_that_will_be_displayed << sequence
     }
+    ruler_result = Bioroebe.return_ruler(sequence_that_will_be_displayed)
+    e '  '+ruler_result+rev
+    print '  '+mediumslateblue(sequence_that_will_be_displayed)+rev # Print each individual character here.
     e Colours.rev
     e
   end
@@ -159,7 +168,8 @@ class Alignment < ::Bioroebe::CommandlineApplication # === Bioroebe::Alignment
   # === print_row_for
   # ========================================================================= #
   def print_row_for(
-      i = 'A', array = @array_A
+      i     = 'A',
+      array = @array_A
     )
     print "#{rev}  #{i}: " # First output the identifier, e. g. "A" or "T" and so forth.
     array.each {|entry| # entry is a Float.

data/lib/bioroebe/sequence/dna.rb

@@ -83,6 +83,7 @@ class DNA < ::Bioroebe::Sequence # === Bioroebe::DNA
   end; alias to_RNA to_rna # === to_RNA
        alias to_T   to_rna # === to_T
 
+  require 'bioroebe/codons/convert_this_codon_to_that_aminoacid.rb'
   # ========================================================================= #
   # === to_aminoacids
   #

data/lib/bioroebe/sequence/nucleotide_module/nucleotide_module.rb

@@ -72,13 +72,6 @@ module NucleotideModule # === Bioroebe::NucleotideModule
     i.tr('U','T')
   end
 
-  # ========================================================================= #
-  # === to_dna
-  # ========================================================================= #
-  def to_dna
-    seq?.tr('U','T')
-  end; alias dna to_dna # === dna
-
   # ========================================================================= #
   # === n_random_dna
   #
@@ -258,24 +251,6 @@ module NucleotideModule # === Bioroebe::NucleotideModule
     ::Bioroebe.codon_to_aminoacid(codon)
   end; alias translate_aminoacid_into_dna codon_to_aminoacid # === translate_aminoacid_into_dna
 
-  # ========================================================================= #
-  # === to_dna
-  #
-  # This method will convert a RNA sequence into a DNA sequence.
-  #
-  # It will return the translation.
-  #
-  # bio; puts Bioroebe.new.to_dna('actgggcgagagklklklklk')
-  # ========================================================================= #
-  def to_dna(
-      i = sequence?, upcase_me = true
-    )
-    if is_RNA?
-      i = sequence? if i.nil?
-      ::Bioroebe.to_dna(i, upcase_me)
-    end
-  end; alias dna to_dna # === dna
-
   # ========================================================================= #
   # === random
   #
@@ -397,6 +372,34 @@ module NucleotideModule # === Bioroebe::NucleotideModule
     end
   end; alias gc_percent gc_percentage # === gc_percent
 
+  # ========================================================================= #
+  # === to_dna
+  #
+  # This method will convert a RNA sequence into a DNA sequence.
+  #
+  # It will return the translation.
+  #
+  # Usage example:
+  #
+  #   require 'bioroebe'; puts Bioroebe::DNA.new('actgggcgagaguuuuUUUUUU').to_dna
+  #
+  # ========================================================================= #
+  def to_dna(
+      i         = sequence?,
+      upcase_me = true
+    )
+    i = sequence? if i.nil?
+    i = ::Bioroebe.to_dna(i, upcase_me)
+    return i
+  end; alias dna to_dna # === dna
+
+  # ========================================================================= #
+  # === to_dna
+  # ========================================================================= #
+  # def to_dna
+  #   seq?.tr('U','T')
+  # end; alias dna to_dna # === dna
+
 end; end
 
 if __FILE__ == $PROGRAM_NAME

data/lib/bioroebe/sequence/protein.rb

@@ -4,7 +4,12 @@
 # =========================================================================== #
 # === Bioroebe::Protein
 #
-# This is a typical sequence of aminoacids.
+# This is a typical sequence of aminoacids. It is not 100% certain whether
+# this class will be retained, but for the time being it will be. Note
+# that peptides should also use this class - while the name may not be
+# 100% accurate (smaller proteins are typically called peptides or
+# oligopeptides) I feel that this is a distinction that does not really
+# make a whole lot of sense.
 # =========================================================================== #
 # require 'bioroebe/sequence/protein.rb'
 # =========================================================================== #
@@ -94,6 +99,9 @@ class Protein < ::Bioroebe::Sequence # === Bioroebe::Protein
   # This method will return true if there are at the least two
   # cysteines in the aminoacid sequence of this protein.
   #
+  # If anyone knows of a better algorithm to determine whether
+  # a protein can REALLY create a disulfide bond let me know.
+  #
   # Usage example:
   #
   #   Bioroebe::Protein.new('MLKLKNASCCEEE').can_form_disulfide_bonds? # => true
@@ -146,7 +154,7 @@ class Protein < ::Bioroebe::Sequence # === Bioroebe::Protein
     chars.each {|this_aminoacid|
       sum += weight_of(this_aminoacid)
     }
-    sum
+    return sum
   end; alias molecular_weight? weight? # === molecular_weight?
 
   # ========================================================================= #
@@ -230,10 +238,99 @@ class Protein < ::Bioroebe::Sequence # === Bioroebe::Protein
     return result
   end
 
+  # ========================================================================= #
+  # === can_be_stained_via_coomassie?
+  #
+  # Determine whether a protein can be stained in a coomassie
+  # staining. This is just a simple, fairly dumb check and
+  # NOT guaranteed to be correct. If anyone has a better
+  # way to check for this let me know.
+  # ========================================================================= #
+  def can_be_stained_via_coomassie?
+    disallowed_aminoacids = %w( K H R W F Y)
+    sequence = sequence?
+    return sequence.chars.uniq.any? {|this_aminoacid|
+      disallowed_aminoacids.include? this_aminoacid
+    }
+  end
+
+  # ========================================================================= #
+  # === aliphatic_index
+  #
+  # This method will calculate the aliphatic acid of an aminoacid,
+  # aka a Protein.
+  #
+  # Usage example:
+  #
+  #    require 'bioroebe'; Bioroebe::Protein.new('MVKSYDRYEYEDCLGIVNSKSSNCVFLNNA').aliphatic_index # => 71.33333
+  #
+  # ========================================================================= #
+  def aliphatic_index(
+      a = 2.9,
+      b = 3.9
+    )
+   composition = {}
+   composition.default = 0
+   chars = sequence?.chars
+   chars.each { |entry| composition[entry] += 1} 
+   (
+     composition['A'] + 
+     a * composition['V'].to_f + 
+     b * (composition['I'] + composition['L'])
+   ).to_f / length.to_f * 100
+  end
+
+  # ========================================================================= #
+  # === Bioroebe::Protein.one_to_three
+  #
+  # Usage example:
+  #
+  #   Bioroebe::Protein.one_to_three('A') # => "Ala"
+  #
+  # ========================================================================= #
+  def self.one_to_three(this_aminoacid = 'A')
+    if this_aminoacid.is_a? Array
+      this_aminoacid = this_aminoacid.join(' ').strip
+    end
+    return ::Bioroebe.one_to_three(this_aminoacid)
+  end
+
+  # ========================================================================= #
+  # === Bioroebe::Protein.name
+  #
+  # Usage example:
+  #
+  #   Bioroebe::Protein.name('A') # => "alanine"
+  #
+  # ========================================================================= #
+  def self.name(this_aminoacid = 'A')
+    Bioroebe.return_long_name_of_this_aminoacid(this_aminoacid).downcase
+  end
+
+  # ========================================================================= #
+  # === Bioroebe::Protein.to_1
+  #
+  # This will convert from the long name of an aminoacid, such as 'alanine',
+  # to the short one-letter abbreviation.
+  #
+  # Usage example:
+  #
+  #   Bioroebe::Protein.to_1('alanine') # => "A"
+  #
+  # ========================================================================= #
+  def self.to_1(this_aminoacid = 'alanine')
+    if this_aminoacid.is_a? Array
+      this_aminoacid = this_aminoacid.join(' ').strip
+    end
+    this_aminoacid.downcase!
+    dataset = YAML.load_file(Bioroebe.file_amino_acids_long_name_to_one_letter)
+    return dataset[this_aminoacid]
+  end
+
 end
 
 # =========================================================================== #
-# This "alias" was added in May 2022.
+# The following "alias" was added in May 2022.
 # =========================================================================== #
 Aminoacids = Protein
 
@@ -267,6 +364,7 @@ end
 
 if __FILE__ == $PROGRAM_NAME
   require 'colours/autoinclude'
+  require 'bioroebe/toplevel_methods/verbose.rb'
   protein = Bioroebe::Protein.new(ARGV)
   e protein.weight?
   e Colours.rev+'For the aminoacid sequence:'
@@ -277,5 +375,9 @@ if __FILE__ == $PROGRAM_NAME
   e
   e "  #{Colours.royalblue(protein.to_rna)}"
   e
+  e 'Can this protein be stained via coomassie brilliant blue?:'
+  e
+  e "  #{lightblue(Bioroebe::VerboseTruth[protein.can_be_stained_via_coomassie?])}"
+  e
 end # protein MAC
     # protein MACCCCAAAAAKKKKLLLLL

data/lib/bioroebe/sequence/rna.rb

@@ -0,0 +1,220 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# === Bioroebe::RNA
+#
+# This is a typical "segment of" RNA, a sequence object.
+# =========================================================================== #
+# require 'bioroebe/sequence/rna.rb'
+# =========================================================================== #
+require 'bioroebe/requires/require_sequence.rb'
+
+module Bioroebe
+
+class RNA < ::Bioroebe::Sequence # === Bioroebe::RNA
+
+  require 'bioroebe/sequence/nucleotide_module/nucleotide_module.rb'
+  include Bioroebe::NucleotideModule
+
+  require 'bioroebe/base/internal_hash_module/internal_hash_module.rb'
+  include Bioroebe::InternalHashModule
+
+  require 'bioroebe/codons/codons.rb'
+
+  # ========================================================================= #
+  # === initialize
+  # ========================================================================= #
+  def initialize(
+      this_sequence  = 'ATCG'
+    )
+    reset
+    super(
+      this_sequence
+    )
+    set_dna_type # Make sure we have a DNA only.
+  end
+
+  # ========================================================================= #
+  # === reset
+  # ========================================================================= #
+  def reset
+    super()
+    reset_the_internal_hash # This should come early on here.
+    # ======================================================================= #
+    # === :is_a_ribozyme
+    #
+    # By default RNAs that are created via RNA.new are NOT considered to
+    # be a ribozyme.
+    # ======================================================================= #
+    @internal_hash[:is_a_ribozyme] = false
+    # ======================================================================= #
+    # === @name_of_the_gene
+    # ======================================================================= #
+    @name_of_the_gene = nil # No name is assigned by default.
+  end
+
+  # ========================================================================= #
+  # === set_name_of_the_gene
+  #
+  # Use this method if you want to give the gene a specific name.
+  # ========================================================================= #
+  def set_name_of_the_gene(i)
+    @name_of_the_gene = i
+  end; alias name=         set_name_of_the_gene # === name=
+       alias set_name      set_name_of_the_gene # === set_name
+       alias name_of_gene= set_name_of_the_gene # === name_of_gene=
+       alias set_gene_name set_name_of_the_gene # === set_gene_name
+
+  # ========================================================================= #
+  # === name_of_gene?
+  # ========================================================================= #
+  def name_of_gene?
+    @name_of_the_gene
+  end; alias name_of_gene name_of_gene? # === name_of_gene
+       alias name?        name_of_gene? # === name?
+
+  # ========================================================================= #
+  # === to_rna
+  #
+  # Convert the main sequence to RNA and return that result.
+  # ========================================================================= #
+  def to_rna
+    string?.tr('T','U')
+  end; alias to_RNA to_rna # === to_RNA
+       alias to_T   to_rna # === to_T
+
+  require 'bioroebe/codons/convert_this_codon_to_that_aminoacid.rb'
+  # ========================================================================= #
+  # === to_aminoacids
+  #
+  # This will convert the given DNA input into the corresponding
+  # aminoacid "output" - aka a translational output, following
+  # the regular conversion of DNA→mRNA→protein.
+  #
+  # If the second argument to this method is true, then we will filter
+  # away all "STOP" elements.
+  # ========================================================================= #
+  def to_aminoacids(
+      i                  = string?,
+      ignore_stop_codons = true
+    )
+    i = [i].flatten
+    # ======================================================================= #
+    # === Handle blocks next
+    # ======================================================================= #
+    if block_given?
+      yielded = yield
+      # ===================================================================== #
+      # We don't have to handle :frame1 since this is the default anyway.
+      # ===================================================================== #
+      case yielded
+      when :frame2
+        i.map! {|entry| entry[1..-1] }
+      when :frame3
+        i.map! {|entry| entry[2..-1] }
+      end
+    end
+    i.map {|entry|
+      if entry and (entry.size > 2) # Must check for at the least 3 nucleotides there.
+        # =================================================================== #
+        # Get a chunk of 3 nucleotides next. This will yield an array of
+        # codons such as this one here:
+        #
+        #   ["GCC", "CAC", "AGG", "CAC", "AAC"]
+        #
+        # =================================================================== #
+        codons = entry.scan(/.../)
+        # =================================================================== #
+        # Next, find the corresponding aminoacid for this codon.
+        # =================================================================== #
+        aminoacids = codons.map {|codon|
+          result = ::Bioroebe.codon_to_aminoacid(codon)
+          result
+        }
+        if ignore_stop_codons
+          aminoacids.reject! {|inner_entry|
+            inner_entry == 'STOP'
+          }
+        end
+        result = aminoacids.join
+        result # Return the result here.
+      else
+        entry
+      end
+    }
+  end; alias to_aa      to_aminoacids # === to_aa
+       alias to_protein to_aminoacids # === to_protein
+
+  # ========================================================================= #
+  # === is_a_ribozyme?
+  # ========================================================================= #
+  def is_a_ribozyme?
+    @internal_hash[:is_a_ribozyme]
+  end
+
+  # ========================================================================= #
+  # === gc_percentage?
+  #
+  # Usage example:
+  #
+  #   x = Bioroebe::DNA.new('TTATTAAGTATTACG'); x.gc_percentage? # => "20.000"
+  #
+  # ========================================================================= #
+  def gc_percentage?
+    require 'bioroebe/calculate/calculate_gc_content.rb'
+    Bioroebe.gc_content(string?)
+  end
+
+end
+
+# =========================================================================== #
+# === Bioroebe.to_aminoacids
+#
+# This method can be used to convert a String such as 'ATG' into the
+# corresponding aminoacid sequence - in this example, the String 'M'.
+#
+# Invocation examples:
+#
+#   Bioroebe.to_aminoacids 'AUGGCCAUGGCGCCCAGAACUGAGAUCAAUAGUACCCGUAUUAACGGGUGA' # => "MAMAPRTEINSTRING"
+#   Bioroebe.to_aminoacids '/rosalind_prot.txt' # => "MAMAPRTEINSTRING"
+#
+# =========================================================================== #
+def self.to_aminoacids(i, &block)
+  if i and File.file?(i)
+    i = File.read(i).strip
+  end
+  result = ::Bioroebe::DNA.new.to_aminoacids(i, &block)
+  if i.is_a?(String) and !result.is_a?(String)
+    # ======================================================================= #
+    # If the user did input a String, then we must make sure that the
+    # returned value will also be a String.
+    # ======================================================================= #
+    result = result.join(' ').strip
+  end
+  result
+end; self.instance_eval { alias to_aa          to_aminoacids } # === Bioroebe.to_aa
+     self.instance_eval { alias to_protein     to_aminoacids } # === Bioroebe.to_protein
+     self.instance_eval { alias rna_to_protein to_aminoacids } # === Bioroebe.rna_to_protein 
+
+# =========================================================================== #
+# === Bioroebe.rna_sequence
+#
+# Usage example:
+#
+#   dna = Bioroebe.rna_sequence('ATTCGGU')
+#
+# =========================================================================== #
+def self.rna_sequence(i)
+  i = i.first if i.is_a? Array
+  i.delete!('T') # Reject Thymine there.
+  ::Bioroebe::RNA.new(i)
+end
+
+end
+
+if __FILE__ == $PROGRAM_NAME
+  rna = Bioroebe::RNA.new(ARGV)
+  puts 'The DNA sequence is: '+rna.sequence?
+  puts 'The RNA sequence is: '+rna.to_dna
+end # dna ATCGATCGAAATTACCCCCCCC