bio 0.7.0

data/lib/bio/feature.rb

@@ -0,0 +1,201 @@
+#
+# = bio/feature.rb - Features/Feature class (GenBank Feature table)
+#
+# Copyright::	Copyright (c) 2002, 2005
+#		Toshiaki Katayama <k@bioruby.org>
+# License::	LGPL
+#
+# $Id: feature.rb,v 1.9 2005/11/30 01:54:38 k Exp $
+#
+#--
+# *TODO*
+# add to_gff method
+#++
+#
+# == INSD Feature table definition
+#
+# See http://www.ddbj.nig.ac.jp/FT/full_index.html for the INSD
+# (GenBank/EMBL/DDBJ) Feature table definition.
+#
+# === Example
+#
+#  # suppose features is a Bio::Features object
+#  features.each do |feature|
+#    f_name = feature.feature
+#    f_pos  = feature.position
+#    puts "#{f_name}:\t#{f_pos}"
+#    feature.each do |qualifier|
+#      q_name = qualifier.qualifier
+#      q_val  = qualifier.value
+#      puts "- #{q_name}:\t#{q_val}"
+#    end
+#  end
+#
+#  # Iterates only on CDS features and extract translated amino acid sequences
+#  features.each("CDS") do |feature|
+#    hash = feature.assoc
+#    name = hash["gene"] || hash["product"] || hash["note"] 
+#    seq  = hash["translation"]
+#    pos  = feature.position
+#    if gene and seq
+#      puts ">#{gene} #{feature.position}"
+#      puts aaseq
+#    end
+#  end
+#
+#--
+#
+#  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
+#
+#++
+#
+
+require 'bio/location'
+
+module Bio
+
+# Container for the sequence annotation.
+class Feature
+
+  def initialize(feature = '', position = '', qualifiers = [])
+    @feature, @position, @qualifiers = feature, position, qualifiers
+  end
+
+  # Returns type of feature in String (e.g 'CDS', 'gene')
+  attr_accessor :feature
+
+  # Returns position of the feature in String (e.g. 'complement(123..146)')
+  attr_accessor :position
+
+  # Returns an Array of Qualifier objects.
+  attr_accessor :qualifiers
+
+  # Returns a Bio::Locations object translated from the position string.
+  def locations
+    Locations.new(@position)
+  end
+
+  # Appends a Qualifier object to the Feature.
+  #
+  # * Returns an Array of Qualifier objects.
+  # * If the argument is not a Qualifier object, returns nil.
+  #
+  def append(a)
+    @qualifiers.push(a) if a.is_a? Qualifier
+    return self
+  end
+
+  # Iterates on each qualifier.
+  def each(arg = nil)
+    @qualifiers.each do |x|
+      next if arg and x.qualifier != arg
+      yield x
+    end
+  end
+
+  # Returns a Hash constructed from qualifier objects.
+  def assoc
+    STDERR.puts "Bio::Feature#assoc is deprecated, use Bio::Feature#to_hash instead" if $DEBUG
+    hash = Hash.new
+    @qualifiers.each do |x|
+      hash[x.qualifier] = x.value
+    end
+    return hash
+  end
+
+  # Returns a Hash constructed from qualifier objects.
+  def to_hash
+    hash = Hash.new
+    @qualifiers.each do |x|
+      hash[x.qualifier] ||= []
+      hash[x.qualifier] << x.value
+    end
+    return hash
+  end
+
+  # Short cut for the Bio::Feature#to_hash[key]
+  def [](key)
+    self.to_hash[key]
+  end
+
+  # Container for the qualifier-value pair.
+  class Qualifier
+
+    def initialize(key, value)
+      @qualifier, @value = key, value
+    end
+
+    # Qualifier name in String
+    attr_reader :qualifier
+
+    # Qualifier value in String
+    attr_reader :value
+
+  end
+
+end
+
+
+# Container for the list of Feature objects.
+class Features
+
+  def initialize(ary = [])
+    @features = ary
+  end
+
+  # Returns an Array of Feature objects.
+  attr_accessor :features
+
+  def to_gff
+    # *TODO*
+    # to generate Bio::GFF object and implement Bio::GFF#to_s or
+    # to generate GFF string in this method?
+  end
+
+  # Appends a Feature object to Features.
+  def append(a)
+    @features.push(a) if a.is_a? Feature
+    return self
+  end
+
+  # Iterates on each feature.  If a feature name is given as an argument,
+  # only iterates on each feature belongs to the name (e.g. 'CDS' etc.)
+  def each(arg = nil)
+    @features.each do |x|
+      next if arg and x.feature != arg
+      yield x
+    end
+  end
+
+  # Short cut for the Features#features[n]
+  def [](*arg)
+    @features[*arg]
+  end
+
+  # Short cut for the Features#features.first
+  def first
+    @features.first
+  end
+
+  # Short cut for the Features#features.last
+  def last
+    @features.last
+  end
+
+end
+
+end # Bio
+
+

data/lib/bio/io/brdb.rb

@@ -0,0 +1,103 @@
+#
+# bio/io/brdb.rb - BioRuby-DB access module
+#
+#   Copyright (C) 2001 KATAYAMA Toshiaki <k@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: brdb.rb,v 1.4 2005/09/26 13:00:08 k Exp $
+#
+
+begin
+  require 'dbi'
+rescue LoadError
+end
+
+module Bio
+
+  class BRDB
+
+    def initialize(*args)
+      @brdb = args
+    end
+
+    def fetch(db_table, entry_id)
+      DBI.connect(*@brdb) do |dbh|
+        query = "select * from #{db_table} where id = ?"
+        dbh.execute(query, entry_id).fetch_all
+      end
+    end
+
+    def insert(db_table, values)
+      if values.is_a?(Array)
+        values = values.map{ |x| '"' + DBI.quote(x) + '"' }.join(",")
+      end
+      DBI.connect(*@brdb) do |dbh|
+        query = "insert into #{db_table} values (?);"
+        dbh.execute(query, values)
+      end
+    end
+
+    def update(db_table, entry_id, values)
+      if values.is_a?(Hash)
+        values = values.to_a.map{ |k, v| "#{k}='#{DBI.quote(v)}'" }.join(',')
+      end
+      DBI.connect(*@brdb) do |dbh|
+        query = "update #{db_table} set ? where id = ?"
+        dbh.execute(query, values, entry_id)
+      end
+    end
+
+    def search(db_table, field, keyword)
+    end
+
+  end
+
+end
+
+
+if __FILE__ == $0
+  begin
+    require 'pp'
+    alias p pp
+  rescue LoadError
+  end
+
+  db    = 'dbi:Mysql:host=db.bioruby.org;database=genbank'
+  user  = 'root'
+
+  serv = Bio::BRDB.new(db, user)
+
+  serv.fetch('ent', 'AA2CG').each do |row|
+    p row.to_h
+  end
+  serv.fetch('ft', 'AA2CG').each do |row|
+    p row.to_h
+  end
+end
+
+
+=begin
+
+= Bio::BRDB
+
+--- Bio::BRDB.new(*args)
+
+--- Bio::BRDB#close
+--- Bio::BRDB#fetch(db_table, entry_id)
+--- Bio::BRDB#update(db_table, entry_id, hash)
+--- Bio::BRDB#insert(db_table, ary)
+
+=end

data/lib/bio/io/das.rb

@@ -0,0 +1,471 @@
+#
+# = bio/io/das.rb - BioDAS access module
+#
+# Copyright::	Copyright (C) 2003, 2004
+#		Shuichi Kawashima <shuichi@hgc.jp>,
+#		Toshiaki Katayama <k@bioruby.org>
+# License::	LGPL
+#
+# $Id: das.rb,v 1.11 2005/11/14 02:01:54 k Exp $
+#
+#--
+# == TODO
+#
+#  link, stylesheet
+#
+#++
+#
+#--
+#
+#  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
+  require 'rexml/document'
+rescue LoadError
+end
+require 'uri'
+require 'net/http'
+require 'bio/sequence'
+
+
+module Bio
+
+class DAS
+
+  # Specify DAS server to connect
+  def initialize(url = 'http://www.wormbase.org:80/db/')
+    schema, user, host, port, reg, path, = URI.split(url)
+    @server = Net::HTTP.new(host, port)
+    @prefix = path ? path.chomp('/') : ''
+  end
+
+  # Returns an Array of Bio::DAS::DSN
+  def get_dsn
+    ary = []
+    result, = @server.get(@prefix + '/das/dsn')
+    doc = REXML::Document.new(result.body)
+    doc.elements.each('/descendant::DSN') do |e|
+      dsn = DSN.new
+      e.elements.each do |e|
+        case e.name
+        when 'SOURCE'
+          dsn.source = e.text
+          dsn.source_id = e.attributes['id']
+          dsn.source_version = e.attributes['version']
+        when 'MAPMASTER'
+          dsn.mapmaster = e.name
+        when 'DESCRIPTION'
+          dsn.description = e.text
+          dsn.description_href = e.attributes['href']
+        end
+      end
+      ary << dsn
+    end
+    ary
+  end
+
+  # Returns Bio::DAS::ENTRY_POINT.
+  # The 'dsn' can be a String or a Bio::DAS::DSN object.
+  def get_entry_point(dsn)
+    entry_point = ENTRY_POINT.new
+    dsn = dsn.source if dsn.instance_of?(Bio::DAS::DSN)
+    result, = @server.get(@prefix + '/das/' + dsn + '/entry_points')
+    doc = REXML::Document.new(result.body)
+    doc.elements.each('/descendant::ENTRY_POINTS') do |e|
+      entry_point.href = e.attributes['href']
+      entry_point.version = e.attributes['version']
+      e.elements.each do |e|
+        segment = SEGMENT.new
+        segment.entry_id = e.attributes['id']
+        segment.start = e.attributes['start']
+        segment.stop = e.attributes['stop']
+        segment.stop = e.attributes['orientation']
+        segment.subparts = e.attributes['subparts']
+        segment.description = e.text
+        entry_point.segments << segment
+      end
+    end
+    entry_point
+  end
+
+  # Returns an Array of Bio::DAS::DNA.
+  # The 'dsn' can be a String or a Bio::DAS::DSN object.
+  # The 'segments' can be a Bio::DAS::SEGMENT object or an Array of
+  # Bio::DAS::SEGMENT
+  def get_dna(dsn, segments)
+    ary = []
+
+    dsn = dsn.source if dsn.instance_of?(DSN)
+    segments = [segments] if segments.instance_of?(SEGMENT)
+
+    opts = []
+    segments.each do |s|
+      opts << "segment=#{s.entry_id}:#{s.start},#{s.stop}"
+    end
+    query = opts.join(';')
+
+    result, = @server.get(@prefix + '/das/' + dsn + '/dna?' + query)
+    doc = REXML::Document.new(result.body)
+    doc.elements.each('/descendant::SEQUENCE') do |e|
+      sequence = DNA.new
+      sequence.entry_id = e.attributes['id']
+      sequence.start = e.attributes['start']
+      sequence.stop = e.attributes['stop']
+      sequence.version = e.attributes['version']
+      e.elements.each do |e|
+        sequence.sequence = Bio::Sequence::NA.new(e.text)
+        sequence.length = e.attributes['length'].to_i
+      end
+      ary << sequence
+    end
+    ary
+  end
+
+  # Returns an Array of Bio::DAS::SEQUENCE.
+  # The 'dsn' can be a String or a Bio::DAS::DSN object.
+  # The 'segments' can be a Bio::DAS::SEGMENT object or an Array of
+  # Bio::DAS::SEGMENT
+  def get_sequence(dsn, segments)
+    ary = []
+
+    dsn = dsn.source if dsn.instance_of?(DSN)
+    segments = [segments] if segments.instance_of?(SEGMENT)
+
+    opts = []
+    segments.each do |s|
+      opts << "segment=#{s.entry_id}:#{s.start},#{s.stop}"
+    end
+    query = opts.join(';')
+
+    result, = @server.get(@prefix + '/das/' + dsn + '/sequence?' + query)
+    doc = REXML::Document.new(result.body)
+    doc.elements.each('/descendant::SEQUENCE') do |e|
+      sequence = SEQUENCE.new
+      sequence.entry_id = e.attributes['id']
+      sequence.start = e.attributes['start']
+      sequence.stop = e.attributes['stop']
+      sequence.moltype = e.attributes['moltype']
+      sequence.version = e.attributes['version']
+      case sequence.moltype
+      when /dna|rna/i		# 'DNA', 'ssRNA', 'dsRNA'
+        sequence.sequence = Bio::Sequence::NA.new(e.text)
+      when /protein/i		# 'Protein
+        sequence.sequence = Bio::Sequence::AA.new(e.text)
+      else
+        sequence.sequence = e.text
+      end
+      ary << sequence
+    end
+    ary
+  end
+
+  # Returns a Bio::DAS::TYPES object.
+  # The 'dsn' can be a String or a Bio::DAS::DSN object.
+  # The 'segments' is optional and can be a Bio::DAS::SEGMENT object or
+  # an Array of Bio::DAS::SEGMENT
+  def get_types(dsn, segments = [])	# argument 'type' is deprecated
+    types = TYPES.new
+
+    dsn = dsn.source if dsn.instance_of?(DSN)
+    segments = [segments] if segments.instance_of?(SEGMENT)
+
+    opts = []
+    segments.each do |s|
+      opts << "segment=#{s.entry_id}:#{s.start},#{s.stop}"
+    end
+    query = opts.join(';')
+
+    result, = @server.get(@prefix + '/das/' + dsn + '/types?' + query)
+    doc = REXML::Document.new(result.body)
+    doc.elements.each('/descendant::GFF') do |e|
+      types.version = e.attributes['version']
+      types.href = e.attributes['href']
+      e.elements.each do |e|
+        segment = SEGMENT.new
+        segment.entry_id = e.attributes['id']
+        segment.start = e.attributes['start']
+        segment.stop = e.attributes['stop']
+        segment.version = e.attributes['version']
+        segment.label = e.attributes['label']
+        e.elements.each do |e|
+          t = TYPE.new
+          t.entry_id = e.attributes['id']
+          t.method = e.attributes['method']
+          t.category = e.attributes['category']
+          t.count = e.text.to_i
+          segment.types << t
+        end
+        types.segments << segment
+      end
+    end
+    types
+  end
+
+  # Returns a Bio::DAS::GFF object.
+  # The 'dsn' can be a String or a Bio::DAS::DSN object.
+  # The 'segments' is optional and can be a Bio::DAS::SEGMENT object or
+  # an Array of Bio::DAS::SEGMENT
+  def get_features(dsn, segments = [], categorize = false, feature_ids = [], group_ids = [])
+    # arguments 'type' and 'category' are deprecated
+    gff = GFF.new
+
+    dsn = dsn.source if dsn.instance_of?(DSN)
+    segments = [segments] if segments.instance_of?(SEGMENT)
+
+    opts = []
+    segments.each do |s|
+      opts << "segment=#{s.entry_id}:#{s.start},#{s.stop}"
+    end
+    if categorize
+      opts << "categorize=yes"	# default is 'no'
+    end
+    feature_ids.each do |fid|
+      opts << "feature_id=#{fid}"
+    end
+    group_ids.each do |gid|
+      opts << "group_id=#{gid}"
+    end
+    query = opts.join(';')
+
+    result, = @server.get(@prefix + '/das/' + dsn + '/features?' + query)
+    doc = REXML::Document.new(result.body)
+    doc.elements.each('/descendant::GFF') do |e|
+      gff.version = e.attributes['version']
+      gff.href = e.attributes['href']
+      e.elements.each('SEGMENT') do |e|
+        segment = SEGMENT.new
+        segment.entry_id = e.attributes['id']
+        segment.start = e.attributes['start']
+        segment.stop = e.attributes['stop']
+        segment.version = e.attributes['version']
+        segment.label = e.attributes['label']
+        e.elements.each do |e|
+          feature = FEATURE.new
+          feature.entry_id = e.attributes['id']
+          feature.label = e.attributes['label']
+          e.elements.each do |e|
+            case e.name
+            when 'TYPE'
+              type = TYPE.new
+              type.entry_id = e.attributes['id']
+              type.category = e.attributes['category']
+              type.reference = e.attributes['referrence']
+              type.label = e.text
+              feature.types << type
+            when 'METHOD'
+              feature.method_id = e.attributes['id']
+              feature.method = e.text
+            when 'START'
+              feature.start = e.text
+            when 'STOP', 'END'
+              feature.stop = e.text
+            when 'SCORE'
+              feature.score = e.text
+            when 'ORIENTATION'
+              feature.orientation = e.text
+            when 'PHASE'
+              feature.phase = e.text
+            when 'NOTE'
+              feature.notes << e.text
+            when 'LINK'
+              link = LINK.new
+              link.href = e.attributes['href']
+              link.text = e.text
+              feature.links << link
+            when 'TARGET'
+              target = TARGET.new
+              target.entry_id = e.attributes['id']
+              target.start = e.attributes['start']
+              target.stop = e.attributes['stop']
+              target.name = e.text
+              feature.targets << target
+            when 'GROUP'
+              group = GROUP.new
+              group.entry_id = e.attributes['id']
+              group.label = e.attributes['label']
+              group.type = e.attributes['type']
+              e.elements.each do |e|
+                case e.name
+                when 'NOTE'		# in GROUP
+                  group.notes << e.text
+                when 'LINK'		# in GROUP
+                  link = LINK.new
+                  link.href = e.attributes['href']
+                  link.text = e.text
+                  group.links << link
+                when 'TARGET'		# in GROUP
+                  target = TARGET.new
+                  target.entry_id = e.attributes['id']
+                  target.start = e.attributes['start']
+                  target.stop = e.attributes['stop']
+                  target.name = e.text
+                  group.targets << target
+                end
+              end
+              feature.groups << group
+            end
+          end
+          segment.features << feature
+        end
+        gff.segments << segment
+      end
+    end
+    gff
+  end
+
+
+  class DSN
+    attr_accessor :source, :source_id, :source_version,
+      :mapmaster, :description, :description_href
+  end
+
+  class ENTRY_POINT
+    def initialize
+      @segments = Array.new
+    end
+    attr_reader :segments
+    attr_accessor :href, :version
+
+    def each
+      @segments.each do |x|
+        yield x
+      end
+    end
+  end
+
+  class SEGMENT
+    def self.region(entry_id, start, stop)
+      segment = self.new
+      segment.entry_id = entry_id
+      segment.start = start
+      segment.stop = stop
+      return segment
+    end
+
+    def initialize
+      @features = Array.new		# for FEATURE
+      @types = Array.new		# for TYPE
+    end
+    attr_accessor :entry_id, :start, :stop, :orientation, :description,
+      :subparts,			# optional
+      :features, :version, :label,	# for FEATURE
+      :types				# for TYPE
+  end
+
+  class DNA
+    attr_accessor :entry_id, :start, :stop, :version, :sequence, :length
+  end
+
+  class SEQUENCE
+    attr_accessor :entry_id, :start, :stop, :moltype, :version, :sequence
+  end
+
+  class TYPES < ENTRY_POINT; end
+
+  class TYPE
+    attr_accessor :entry_id, :method, :category, :count,
+      :reference, :label	# for FEATURE
+  end
+
+  class GFF
+    def initialize
+      @segments = Array.new
+    end
+    attr_reader :segments
+    attr_accessor :version, :href
+  end
+
+  class FEATURE
+    def initialize
+      @notes = Array.new
+      @links = Array.new
+      @types = Array.new
+      @targets = Array.new
+      @groups = Array.new
+    end
+    attr_accessor :entry_id, :label,
+      :method_id, :method, :start, :stop, :score, :orientation, :phase
+    attr_reader :notes, :links, :types, :targets, :groups
+  end
+
+  class LINK
+    attr_accessor :href, :text
+  end
+
+  class TARGET
+    attr_accessor :entry_id, :start, :stop, :name
+  end
+
+  class GROUP
+    def initialize
+      @notes = Array.new
+      @links = Array.new
+      @targets = Array.new
+    end
+    attr_accessor :entry_id, :label, :type
+    attr_reader :notes, :links, :targets
+  end
+
+end
+
+end # module Bio
+
+
+if __FILE__ == $0
+
+# begin
+#   require 'pp'
+#   alias p pp
+# rescue LoadError
+# end
+
+  puts "### WormBase"
+  wormbase = Bio::DAS.new('http://www.wormbase.org/db/')
+
+  puts ">>> test get_dsn"
+  p wormbase.get_dsn
+
+  puts ">>> create segment obj Bio::DAS::SEGMENT.region('I', 1, 1000)"
+  seg = Bio::DAS::SEGMENT.region('I', 1, 1000)
+  p seg
+
+  puts ">>> test get_dna"
+  p wormbase.get_dna('elegans', seg)
+
+  puts "### test get_features"
+  p wormbase.get_features('elegans', seg)
+
+  puts "### KEGG DAS"
+  kegg_das = Bio::DAS.new("http://das.hgc.jp/cgi-bin/")
+
+  dsn_list = kegg_das.get_dsn
+  org_list = dsn_list.collect {|x| x.source}
+
+  puts ">>> dsn : entry_points"
+  org_list.each do |org|
+    print "#{org} : "
+    list = kegg_das.get_entry_point(org)
+    list.segments.each do |seg|
+      print " #{seg.entry_id}"
+    end
+    puts
+  end
+
+end
+
+