bio 0.7.0

data/lib/bio/db/rebase.rb

@@ -0,0 +1,417 @@
+require 'bio/reference'
+module Bio
+
+#
+# bio/db/rebase.rb - Interface for EMBOSS formatted REBASE files
+#
+# Copyright::  Copyright (C) 2005 Trevor Wennblom <trevor@corevx.com>
+# License::    LGPL
+#
+#  $Id: rebase.rb,v 1.2 2005/12/13 15:02:41 trevor Exp $
+#
+#
+#--
+#
+#  This library is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2 of the License, or (at your option) any later version.
+#
+#  This library is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with this library; if not, write to the Free Software
+#  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
+#
+#++
+#
+#
+
+=begin rdoc
+bio/db/rebase.rb - Interface for EMBOSS formatted REBASE files
+
+== Synopsis
+
+Bio::REBASE provides utilties for interacting with REBASE data in EMBOSS
+format.  REBASE is the Restriction Enzyme Database, more information
+can be found here:
+* http://rebase.neb.com
+
+EMBOSS formatted files located at:
+* http://rebase.neb.com/rebase/rebase.f37.html
+
+These files are the same as the "emboss_?.???" files located at:
+* ftp://ftp.neb.com/pub/rebase/
+
+To easily get started with the data you can simply type this command at your shell prompt:
+  wget ftp://ftp.neb.com/pub/rebase/emboss*
+
+
+== Usage
+
+  require 'bio/db/rebase'
+  require 'pp'
+
+  enz = File.read('emboss_e')
+  ref = File.read('emboss_r')
+  sup = File.read('emboss_s')
+
+  # When creating a new instance of Bio::REBASE
+  # the contents of the enzyme file must be passed.
+  # The references and suppiers file contents
+  # may also be passed.
+  rebase = Bio::REBASE.new( enz )
+  rebase = Bio::REBASE.new( enz, ref )
+  rebase = Bio::REBASE.new( enz, ref, sup )
+
+  # The 'read' class method allows you to read in files
+  # that are REBASE EMBOSS formatted
+  rebase = Bio::REBASE.read( 'emboss_e' )
+  rebase = Bio::REBASE.read( 'emboss_e', 'emboss_r' )
+  rebase = Bio::REBASE.read( 'emboss_e', 'emboss_r', 'emboss_s' )
+
+  # The data loaded may be saved in YAML format
+  rebase.save_yaml( 'enz.yaml' )
+  rebase.save_yaml( 'enz.yaml', 'ref.yaml' )
+  rebase.save_yaml( 'enz.yaml', 'ref.yaml', 'sup.yaml' )
+
+  # YAML formatted files can also be read with the
+  # class method 'load_yaml'
+  rebase = Bio::REBASE.load_yaml( 'enz.yaml' )
+  rebase = Bio::REBASE.load_yaml( 'enz.yaml', 'ref.yaml' )
+  rebase = Bio::REBASE.load_yaml( 'enz.yaml', 'ref.yaml', 'sup.yaml' )
+
+  pp rebase.enzymes[0..4]                     # ["AarI", "AasI", "AatI", "AatII", "Acc16I"]
+  pp rebase['AarI'].pattern                   # "CACCTGC"
+  pp rebase['AarI'].blunt?                    # false
+  pp rebase['AarI'].organism                  # "Arthrobacter aurescens SS2-322"
+  pp rebase['AarI'].source                    # "A. Janulaitis"
+  pp rebase['AarI'].primary_strand_cut1       # 11
+  pp rebase['AarI'].primary_strand_cut2       # 0
+  pp rebase['AarI'].complementary_strand_cut1 # 15
+  pp rebase['AarI'].complementary_strand_cut2 # 0
+  pp rebase['AarI'].suppliers                 # ["F"]
+  pp rebase['AarI'].supplier_names            # ["Fermentas International Inc."]
+
+  pp rebase['AarI'].isoschizomers             # Currently none stored in the references file
+  pp rebase['AarI'].methylation               # ""
+
+  pp rebase['EcoRII'].methylation             # "2(5)"
+  pp rebase['EcoRII'].suppliers               # ["F", "J", "M", "O", "S"]
+  pp rebase['EcoRII'].supplier_names  # ["Fermentas International Inc.", "Nippon Gene Co., Ltd.",
+                                      # "Roche Applied Science", "Toyobo Biochemicals",
+                                      # "Sigma Chemical Corporation"]
+
+  # Number of enzymes in the database
+  pp rebase.size                              # 673
+  pp rebase.enzymes.size                      # 673
+
+  rebase.each do |name, info|
+    pp "#{name}:  #{info.methylation}" unless info.methylation.empty?
+  end
+
+
+== Author
+Trevor Wennblom <trevor@corevx.com>
+
+
+== Copyright
+Copyright (C) 2005 Trevor Wennblom
+Licensed under the same terms as BioRuby.
+
+=end
+
+class REBASE
+  autoload(:YAML, 'yaml')
+
+  class DynamicMethod_Hash < Hash
+    # Define a writer or reader
+    # * Allows hash[:kay]= to be accessed like hash.key=
+    # * Allows hash[:key] to be accessed like hash.key
+    def method_missing(method_id, *args)
+      k = self.class
+      if method_id.to_s[-1].chr == '='
+        k.class_eval do
+          define_method(method_id) { |s| self[ method_id.to_s[0..-2].to_sym ] = s }
+        end
+        k.instance_method(method_id).bind(self).call(args[0])
+      else
+        k.class_eval do
+          define_method(method_id) { self[method_id] }
+        end
+        k.instance_method(method_id).bind(self).call
+      end
+    end
+  end
+
+  class EnzymeEntry < DynamicMethod_Hash
+    @@supplier_data = {}
+    def self.supplier_data=(d); @@supplier_data = d; end
+
+    def supplier_names
+      ret = []
+      self.suppliers.each { |s| ret << @@supplier_data[s] }
+      ret
+    end
+  end
+
+  def each
+    @data.each { |v| yield v }
+  end
+
+  # Make the instantiated class act like a Hash on @data
+  # Does the equivalent and more of this:
+  #  def []( key ); @data[ key ]; end
+  #  def size; @data.size; end
+  def method_missing(method_id, *args)
+    self.class.class_eval do
+      define_method(method_id) { |a| Hash.instance_method(method_id).bind(@data).call(a) }
+    end
+    Hash.instance_method(method_id).bind(@data).call(*args)
+  end
+
+  # All your REBASE are belong to us.
+  def initialize( enzyme_lines, reference_lines = nil, supplier_lines = nil, yaml = false )
+    if yaml
+      @enzyme_data = enzyme_lines
+      @reference_data = reference_lines
+      @supplier_data = supplier_lines
+    else
+      @enzyme_data = parse_enzymes(enzyme_lines)
+      @reference_data = parse_references(reference_lines)
+      @supplier_data = parse_suppliers(supplier_lines)
+    end
+
+    EnzymeEntry.supplier_data = @supplier_data
+    setup_enzyme_data
+  end
+
+  # List the enzymes available
+  def enzymes
+    @data.keys.sort
+  end
+
+  # Save the current data
+  #  rebase.save_yaml( 'enz.yaml' )
+  #  rebase.save_yaml( 'enz.yaml', 'ref.yaml' )
+  #  rebase.save_yaml( 'enz.yaml', 'ref.yaml', 'sup.yaml' )
+  def save_yaml( f_enzyme, f_reference=nil, f_supplier=nil )
+    File.open(f_enzyme, 'w') { |f| f.puts YAML.dump(@enzyme_data) }
+    File.open(f_reference, 'w') { |f| f.puts YAML.dump(@reference_data) } if f_reference
+    File.open(f_supplier, 'w') { |f| f.puts YAML.dump(@supplier_data) } if f_supplier
+  end
+
+  # Read REBASE EMBOSS-formatted files
+  #  rebase = Bio::REBASE.read( 'emboss_e' )
+  #  rebase = Bio::REBASE.read( 'emboss_e', 'emboss_r' )
+  #  rebase = Bio::REBASE.read( 'emboss_e', 'emboss_r', 'emboss_s' )
+  def self.read( f_enzyme, f_reference=nil, f_supplier=nil )
+    e = IO.readlines(f_enzyme)
+    r = f_reference ? IO.readlines(f_reference) : nil
+    s = f_supplier ? IO.readlines(f_supplier) : nil
+    self.new(e,r,s)
+  end
+
+  # Read YAML formatted files
+  #  rebase = Bio::REBASE.load_yaml( 'enz.yaml' )
+  #  rebase = Bio::REBASE.load_yaml( 'enz.yaml', 'ref.yaml' )
+  #  rebase = Bio::REBASE.load_yaml( 'enz.yaml', 'ref.yaml', 'sup.yaml' )
+  def self.load_yaml( f_enzyme, f_reference=nil, f_supplier=nil )
+    e = YAML.load_file(f_enzyme)
+    r = f_reference ? YAML.load_file(f_reference) : nil
+    s = f_supplier ? YAML.load_file(f_supplier) : nil
+    self.new(e,r,s,true)
+  end
+
+  #########
+  protected
+  #########
+
+  def setup_enzyme_data
+    @data = {}
+    
+    @enzyme_data.each do |name, hash|
+      @data[name] = EnzymeEntry.new
+      d = @data[name]
+      d.pattern                   = hash[:pattern]
+      # d.blunt?= is a syntax error
+      d[:blunt?] = (hash[:blunt].to_i == 1 ? true : false)
+      d.primary_strand_cut1       = hash[:c1].to_i
+      d.complementary_strand_cut1 = hash[:c2].to_i
+      d.primary_strand_cut2       = hash[:c3].to_i
+      d.complementary_strand_cut2 = hash[:c4].to_i
+
+      # Set up keys just in case there's no reference data supplied
+      [:organism, :isoschizomers, 
+      :methylation, :source].each { |k| d[k] = '' }
+      d.suppliers = []
+      d.references = []
+    end
+
+    setup_enzyme_and_reference_association
+  end
+
+  def setup_enzyme_and_reference_association
+    return unless @reference_data
+    @reference_data.each do |name, hash|
+      d = @data[name]
+      [:organism, :isoschizomers, 
+      :methylation, :source].each { |k| d[k] = hash[k] }
+      d.suppliers = hash[:suppliers].split('')
+      d.references = []
+      hash[:references].each { |k| d.references << raw_to_reference(k) }
+    end
+  end
+
+  # data is a hash indexed by the :name of each entry which is also a hash
+  # * data[enzyme_name] has the following keys:
+  #   :name, :pattern, :len, :ncuts, :blunt, :c1, :c2, :c3, :c4
+  #   :c1 => First 5' cut
+  #   :c2 => First 3' cut
+  #   :c3 => Second 5' cut
+  #   :c4 => Seocnd 3' cut
+  def parse_enzymes( lines )
+    data = {}
+    return data if lines == nil
+    lines.each do |line|
+      next if line[0].chr == '#'
+      line.chomp!
+      
+      a = line.split("\s")
+      
+      data[ a[0] ] = {
+        :name => a[0],
+        :pattern => a[1],
+        :len => a[2],
+        :ncuts => a[3],
+        :blunt => a[4],
+        :c1 => a[5],
+        :c2 => a[6],
+        :c3 => a[7],
+        :c4 => a[8]
+      }
+    end  # lines.each
+    data
+  end
+
+  # data is a hash indexed by the :name of each entry which is also a hash
+  # * data[enzyme_name] has the following keys:
+  #   :organism, :isoschizomers, :references, :source, :methylation, :suppliers, :name, :number_of_references
+  def parse_references( lines )
+    data = {}
+    return data if lines == nil
+    index = 1
+    h = {}
+    references_left = 0
+
+    lines.each do |line|
+      next if line[0].chr == '#'  # Comment
+      next if line[0..1] == '//'  # End of entry marker
+      line.chomp!
+
+      if (1..7).include?( index )
+        h[index] = line
+        references_left = h[index].to_i if index == 7
+        index += 1
+        next
+      end
+
+      if index == 8
+        h[index] ||= []
+        h[index] << line
+        references_left -= 1
+      end
+
+      if references_left == 0
+        data[ h[1] ] = {
+          :name => h[1],
+          :organism => h[2],
+          :isoschizomers => h[3],
+          :methylation => h[4],
+          :source => h[5],
+          :suppliers => h[6],
+          :number_of_references => h[7],
+          :references => h[8]
+        }
+        index = 1
+        h = {}
+      end
+    end  # lines.each
+    data
+  end
+
+  # data is a hash indexed by the supplier code
+  #   data[supplier_code]
+  #   returns the suppliers name
+  def parse_suppliers( lines )
+    data = {}
+    return data if lines == nil
+    lines.each do |line|
+      next if line[0].chr == '#'
+      data[$1] = $2 if line =~ %r{(.+?)\s(.+)}
+    end
+    data
+  end
+
+  # Takes a string in one of the three formats listed below and returns a
+  # Bio::Reference object
+  # * Possible input styles:
+  #   a = 'Inagaki, K., Hikita, T., Yanagidani, S., Nomura, Y., Kishimoto, N., Tano, T., Tanaka, H., (1993) Biosci. Biotechnol. Biochem., vol. 57, pp. 1716-1721.'
+  #   b = 'Nekrasiene, D., Lapcinskaja, S., Kiuduliene, L., Vitkute, J., Janulaitis, A., Unpublished observations.'
+  #   c = "Grigaite, R., Maneliene, Z., Janulaitis, A., (2002) Nucleic Acids Res., vol. 30."
+  def raw_to_reference( line )
+    a = line.split(', ')
+
+    if a[-1] == 'Unpublished observations.'
+      title = a.pop.chop
+      pages = volume = year = journal = ''
+    else
+      title = ''
+
+      pages_or_volume = a.pop.chop
+      if pages_or_volume =~ %r{pp\.\s}
+        pages = pages_or_volume
+        pages.gsub!('pp. ', '')
+        volume = a.pop
+      else
+        pages = ''
+        volume = pages_or_volume
+      end
+
+      volume.gsub!('vol. ', '')
+
+      year_and_journal = a.pop
+      year_and_journal =~ %r{\((\d+)\)\s(.+)}
+      year = $1
+      journal = $2
+    end
+
+    authors = []
+
+    last_name = nil
+    a.each do |e|
+      if last_name
+        authors << "#{last_name}, #{e}"
+        last_name = nil
+      else
+        last_name = e
+      end
+    end
+
+    ref = {
+      'title' => title,
+      'pages' => pages,
+      'volume' => volume,
+      'year' => year,
+      'journal' => journal,
+      'authors' => authors,
+    }
+
+    Bio::Reference.new(ref)
+  end
+
+end # REBASE
+end # Bio

data/lib/bio/db/transfac.rb

@@ -0,0 +1,387 @@
+#
+# bio/db/transfac.rb - TRANSFAC database class
+#
+#   Copyright (C) 2001 KAWASHIMA Shuichi <s@bioruby.org>
+#
+#  This library is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2 of the License, or (at your option) any later version.
+#
+#  This library is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with this library; if not, write to the Free Software
+#  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
+#
+#  $Id: transfac.rb,v 1.10 2005/11/28 04:57:33 k Exp $
+#
+
+require "bio/db"
+require "matrix"
+
+module Bio
+
+class TRANSFAC < EMBLDB
+
+  DELIMITER	= RS = "\n//\n"
+  TAGSIZE	= 4
+
+  def initialize(entry)
+    super(entry, TAGSIZE)
+  end
+
+  # AC  Accession number                   (1 per entry)
+  #
+  #  AC  T00001   in the case of FACTOR
+  #  AC  M00001   in the case of MATRIX
+  #  AC  R00001   in the case of SITE
+  #  AC  G000001  in the case of GENE
+  #  AC  C00001   in the case of CLASS
+  #  AC  00001    in the case of CELL 
+  #
+  def ac
+    unless @data['AC']
+      @data['AC'] = fetch('AC')
+    end
+    @data['AC']
+  end
+  alias entry_id ac
+
+  # DT  Date                               (1 per entry)
+  #
+  #  DT  DD.MM.YYYY (created); ewi.
+  #  DT  DD.MM.YYYY (updated); mpr.
+  #
+  def dt
+    field_fetch('DT')
+  end
+  alias date dt
+
+  def cc
+    field_fetch('CC')
+  end
+  alias comment cc
+
+  def os
+    field_fetch('OS')
+  end
+  alias org_species os
+
+  def oc
+    field_fetch('OC')
+  end
+  alias org_class oc
+
+  def rn
+    field_fetch('RN')
+  end
+  alias ref_no rn
+
+  def ra
+    field_fetch('RA')
+  end
+  alias ref_authors ra
+
+  def rt
+    field_fetch('RT')
+  end
+  alias ref_title rt
+
+  def rl
+    field_fetch('RL')
+  end
+  alias ref_data rl
+
+
+  class MATRIX < TRANSFAC
+
+    def initialize(entry)
+      super(entry)
+    end
+
+    # NA      Name of the binding factor
+    def na
+      field_fetch('NA')
+    end
+
+    # DE      Short factor description
+    def de
+      field_fetch('DE')
+    end
+
+    # BF      List of linked factor entries
+    def bf
+      field_fetch('bf')
+    end
+
+
+    def ma
+      ma_dat = {}
+      ma_ary = []
+      key = ''
+      @orig.each do |k, v|
+        if k =~ /^0*(\d+)/
+          key = $1.to_i
+          ma_dat[key] = fetch(k) unless ma_dat[key]
+        end
+      end
+      ma_dat.keys.sort.each_with_index do |k, i|
+        rep_nt = ma_dat[k].slice!(-1, 1)
+        ma_dat[k].slice!(-1, 1)
+        ma_ary[i] = ma_dat[k].split(/\s+/)
+        ma_ary[i].each_with_index do |x, j|
+          ma_ary[i][j] = x.to_i
+        end
+      end
+      Matrix[*ma_ary]
+    end
+
+    # BA      Statistical basis
+    def ba
+      field_fetch('BA')
+    end
+
+  end
+
+
+  class SITE < TRANSFAC
+
+    def initialize(entry)
+      super(entry)
+    end
+
+    def ty
+      field_fetch('TY')
+    end
+
+    def de
+      field_fetch('DE')
+    end
+
+    def re
+      field_fetch('RE')
+    end
+
+    def sq
+      field_fetch('SQ')
+    end
+
+    def el
+      field_fetch('EL')
+    end
+
+    def sf
+      field_fetch('SF')
+    end
+
+    def st
+      field_fetch('ST')
+    end
+
+    def s1
+      field_fetch('S1')
+    end
+
+    def bf
+      field_fetch('BF')
+    end
+
+    def so 
+      field_fetch('SO')
+    end
+
+    def mm
+      field_fetch('MM')
+    end
+
+    # DR  Cross-references to other databases     (>=0 per entry)
+    def dr
+      field_fetch('DR')
+    end
+
+  end
+
+
+  class FACTOR < TRANSFAC
+
+    def initialize(entry)
+      super(entry)
+    end
+
+    # FA      Factor name
+    def fa
+      field_fetch('FA')
+    end
+
+    # SY      Synonyms
+    def sy
+      field_fetch('SY')
+    end
+
+    # DR  Cross-references to other databases     (>=0 per entry)
+    def dr
+      field_fetch('DR')
+    end
+
+    # HO      Homologs (suggested)
+    def ho
+      field_fetch('HO')
+    end
+
+    # CL      Classification (class accession no.; class identifier; decimal 
+    # CL      classification number.)
+    def cl
+      field_fetch('CL')
+    end
+
+    # SZ      Size (length (number of amino acids); calculated molecular mass 
+    # SZ      in kDa; experimental molecular mass (or range) in kDa 
+    # SZ      (experimental method) [Ref]
+    def sz
+      field_fetch('SZ')
+    end
+
+    # SQ      Sequence
+    def sq
+      field_fetch('SQ')
+    end
+
+    # SC      Sequence comment, i. e. source of the protein sequence
+    def sc
+      field_fetch('SC')
+    end
+
+    # FT      Feature table (1st position     last position    feature)
+    def ft
+      field_fetch('FT')
+    end
+
+    # SF      Structural features
+    def sf
+      field_fetch('SF')
+    end
+
+    # CP      Cell specificity (positive)
+    def cp
+      field_fetch('CP')
+    end
+
+    # CN      Cell specificity (negative)
+    def cn
+      field_fetch('CN')
+    end
+
+    # FF      Functional features
+    def ff
+      field_fetch('FF')
+    end
+
+    # IN      Interacting factors (factor accession no.; factor name; 
+    # IN      biological species.)
+    def in
+      field_fetch('IN')
+    end
+
+    # MX      Matrix (matrix accession no.; matrix identifier)
+    def mx
+      field_fetch('MX')
+    end
+
+    # BS      Bound sites (site accession no.; site ID; quality: N; biological
+    # BS      species)
+    def bs
+      field_fetch('BS')
+    end
+
+  end
+
+
+  class CELL < TRANSFAC
+
+    def initialize(entry)
+      super(entry)
+    end
+
+    # CD   Cell description
+    def cd
+      field_fetch('CD')
+    end
+
+  end
+
+
+  class CLASS < TRANSFAC
+
+    def initialize(entry)
+      super(entry)
+    end
+
+    # CL      Class
+    def cl
+      field_fetch('CL')
+    end
+
+    # SD      Structure description
+    def sd
+      field_fetch('SD')
+    end
+
+    # BF      Factors belonging to this class
+    def bf
+      field_fetch('BF')
+    end
+
+    # DR      PROSITE accession numbers
+    def dr
+      field_fetch('DR')
+    end
+
+  end
+
+
+  class GENE < TRANSFAC
+
+    def initialize(entry)
+      super(entry)
+    end
+
+    # SD      Short description/name of the gene
+    def sd
+      field_fetch('SD')
+    end
+
+    # DE
+    def de
+      field_fetch('DE')
+    end
+
+    # BC      Bucher promoter
+    def bc
+      field_fetch('BC')
+    end
+
+    # BS      TRANSFAC SITE positions and accession numbers
+    def bs
+      field_fetch('BS')
+    end
+
+    # CO      COMPEL accession number
+    def co
+      field_fetch('CO')
+    end
+
+    # TR      TRRD accession number
+    def tr
+      field_fetch('TR')
+    end
+
+  end
+
+end # class TRANSFAC
+
+end # module Bio
+