wwood-bioruby 1.2.11

data/lib/bio/io/registry.rb

@@ -0,0 +1,292 @@
+#
+# = bio/io/registry.rb - OBDA BioRegistry module
+#
+# Copyright::   Copyright (C) 2002, 2003, 2004, 2005
+#               Toshiaki Katayama <k@bioruby.org>
+# License::     The Ruby License
+#
+# $Id:$
+#
+# == Description
+#
+# BioRegistry read the OBDA (Open Bio Database Access) configuration file
+# (seqdatabase.ini) and create a registry object.  OBDA is created during
+# the BioHackathon held in Tucson and South Africa in 2002 as a project
+# independent set of protocols to access biological databases.  The spec
+# is refined in the BioHackathon 2003 held in Singapore.
+#
+# By using the OBDA, user can access to the database by get_database method
+# without knowing where and how the database is stored, and each database
+# has the get_by_id method to obtain a sequence entry.
+#
+# Sample configuration file is distributed with BioRuby package which
+# consists of stanza format entries as following:
+#
+#   VERSION=1.00
+#
+#   [myembl]
+#   protocol=biofetch
+#   location=http://www.ebi.ac.uk/cgi-bin/dbfetch
+#   dbname=embl
+#
+#   [mysp]
+#   protocol=biosql
+#   location=db.bioruby.org
+#   dbname=biosql
+#   driver=mysql
+#   user=root
+#   pass= 
+#   biodbname=swissprot
+#
+# The first line means that this configration file is version 1.00.
+#
+# The [myembl] line defines a user defined database name 'myembl' and
+# following block indicates how the database can be accessed.
+# In this example, the 'myembl' database is accecced via the OBDA's
+# BioFetch protocol to the dbfetch server at EBI, where the EMBL
+# database is accessed by the name 'embl' on the server side.
+#
+# The [mysp] line defines another database 'mysp' which accesses the
+# RDB (Relational Database) at the db.bioruby.org via the OBDA's
+# BioSQL protocol.  This BioSQL server is running MySQL database as
+# its backend and stores the SwissProt database by the name 'swissprot'
+# and which can be accessed by 'root' user without password.
+# Note that the db.bioruby.org server is a dummy for the explanation.
+#
+# The configuration file is searched by the following order.
+#
+# 1. Local file name given to the Bio::Registry.new(filename).
+#
+# 2. Remote or local file list given by the environmenetal variable
+#    'OBDA_SEARCH_PATH', which is a '+' separated string of the
+#    remote (HTTP) and/or local files.
+#
+#      e.g. OBDA_SEARCH_PATH="http://example.org/obda.ini+$HOME/lib/myobda.ini"
+#
+# 3. Local file "$HOME/.bioinformatics/seqdatabase.ini" in the user's
+#    home directory.
+#
+# 4. Local file "/etc/bioinformatics/seqdatabase.ini" in the system
+#    configuration directry.
+#
+# All these configuration files are loaded.  If there are database
+# definitions having the same name, the first one is used.
+#
+# If none of these files can be found, Bio::Registry.new will try
+# to use http://www.open-bio.org/registry/seqdatabase.ini file.
+#
+# == References
+# 
+# * http://obda.open-bio.org/
+# * http://cvs.open-bio.org/cgi-bin/viewcvs/viewcvs.cgi/obda-specs/?cvsroot=obf-common
+# * http://www.open-bio.org/registry/seqdatabase.ini
+#
+
+require 'uri'
+require 'net/http'
+require 'bio/command'
+
+
+module Bio
+
+autoload :Fetch,          'bio/io/fetch'
+autoload :SQL,            'bio/io/sql'
+autoload :FlatFile,       'bio/io/flatfile'
+autoload :FlatFileIndex,  'bio/io/flatfile/index'
+
+class Registry
+
+  def initialize(file = nil)
+    @spec_version = nil
+    @databases = Array.new
+    read_local(file) if file
+    env_path = ENV['OBDA_SEARCH_PATH']
+    if env_path and env_path.size > 0
+      read_env(env_path)
+    else
+      read_local("#{ENV['HOME']}/.bioinformatics/seqdatabase.ini")
+      read_local("/etc/bioinformatics/seqdatabase.ini")
+      if @databases.empty?
+        read_remote("http://www.open-bio.org/registry/seqdatabase.ini")
+      end
+    end
+  end
+
+  # Version string of the first configulation file
+  attr_reader :spec_version
+
+  # List of databases (Array of Bio::Registry::DB)
+  attr_reader :databases
+
+  # Returns a dababase handle (Bio::SQL, Bio::Fetch etc.) or nil
+  # if not found (case insensitive).
+  # The handles should have get_by_id method.
+  def get_database(dbname)
+    @databases.each do |db|
+      if db.database == dbname.downcase
+        case db.protocol
+        when 'biofetch'
+          return serv_biofetch(db)
+        when 'biosql'
+          return serv_biosql(db)
+        when 'flat', 'index-flat', 'index-berkeleydb'
+          return serv_flat(db)
+        when 'bsane-corba', 'biocorba'
+          raise NotImplementedError
+        when 'xembl'
+          raise NotImplementedError
+        end
+      end
+    end
+    return nil
+  end
+  alias db get_database
+
+  # Returns a Registry::DB object corresponding to the first dbname
+  # entry in the registry records (case insensitive).
+  def query(dbname)
+    @databases.each do |db|
+      return db if db.database == dbname.downcase
+    end
+  end
+
+  private
+
+  def read_env(path)
+    path.split('+').each do |elem|
+      if /:/.match(elem)
+        read_remote(elem)
+      else
+        read_local(elem)
+      end
+    end
+  end
+
+  def read_local(file)
+    if File.readable?(file)
+      stanza = File.read(file)
+      parse_stanza(stanza)
+    end
+  end
+
+  def read_remote(url)
+    schema, user, host, port, reg, path, = URI.split(url)
+    Bio::Command.start_http(host, port) do |http|
+      response = http.get(path)
+      parse_stanza(response.body)
+    end
+  end
+
+  def parse_stanza(stanza)
+    return unless stanza
+    if stanza[/.*/] =~ /VERSION\s*=\s*(\S+)/
+      @spec_version ||= $1	# for internal use (may differ on each file)
+      stanza[/.*/] = ''	        # remove VERSION line
+    end
+    stanza.each_line do |line|
+      case line
+      when /^\[(.*)\]/
+        dbname = $1.downcase
+        db = Bio::Registry::DB.new($1)
+        @databases.push(db)
+      when /=/
+        tag, value = line.chomp.split(/\s*=\s*/)
+        @databases.last[tag] = value
+      end
+    end
+  end
+
+  def serv_biofetch(db)
+    serv = Bio::Fetch.new(db.location)
+    serv.database = db.dbname
+    return serv
+  end
+
+  def serv_biosql(db)
+    location, port = db.location.split(':')
+    port = db.port unless port
+
+    case db.driver
+    when /mysql/i
+      driver = 'Mysql'
+    when /pg|postgres/i
+      driver = 'Pg'
+    when /oracle/
+    when /sybase/
+    when /sqlserver/
+    when /access/
+    when /csv/
+    when /informix/
+    when /odbc/
+    when /rdb/
+    end
+
+    dbi = [ "dbi", driver, db.dbname, location ].compact.join(':')
+    dbi += ';port=' + port if port
+    serv = Bio::SQL.new(dbi, db.user, db.pass)
+
+    # We can not manage biodbname (for name space) in BioSQL yet.
+    # use db.biodbname here!!
+
+    return serv
+  end
+
+  def serv_flat(db)
+    path = db.location
+    path = File.join(path, db.dbname) if db.dbname
+    serv = Bio::FlatFileIndex.open(path)
+    return serv
+  end
+
+
+  class DB
+
+    def initialize(dbname)
+      @database = dbname
+      @property = Hash.new
+    end
+    attr_reader :database
+
+    def method_missing(meth_id)
+      @property[meth_id.id2name]
+    end
+
+    def []=(tag, value)
+      @property[tag] = value
+    end
+
+  end
+
+end # class Registry
+
+end # module Bio
+
+
+
+if __FILE__ == $0
+  begin
+    require 'pp'
+    alias p pp
+  rescue
+  end
+
+  # Usually, you don't need to pass ARGV.
+  reg = Bio::Registry.new(ARGV[0])
+
+  p reg
+  p reg.query('genbank_biosql')
+
+  serv = reg.get_database('genbank_biofetch')
+  puts serv.get_by_id('AA2CG')
+
+  serv = reg.get_database('genbank_biosql')
+  puts serv.get_by_id('AA2CG')
+
+  serv = reg.get_database('swissprot_biofetch')
+  puts serv.get_by_id('CYC_BOVIN')
+
+  serv = reg.get_database('swissprot_biosql')
+  puts serv.get_by_id('CYC_BOVIN')
+end
+
+

data/lib/bio/io/soapwsdl.rb

@@ -0,0 +1,119 @@
+#
+# = bio/io/soapwsdl.rb - SOAP/WSDL interface class
+#
+# Copyright::   Copyright (C) 2004 
+#               Toshiaki Katayama <k@bioruby.org>
+# License::     The Ruby License
+#
+# $Id: soapwsdl.rb,v 1.7 2007/04/05 23:35:41 trevor Exp $
+#
+begin
+  require 'soap/wsdlDriver'
+rescue LoadError
+end
+
+module Bio
+
+# == Examples
+# 
+# class API < Bio::SOAPWSDL
+#   def initialize
+#     @wsdl = 'http://example.com/example.wsdl'
+#     @log = File.new("soap_log", 'w')
+#     create_driver
+#   end
+# end
+#
+# == Use HTTP proxy
+#
+# You need to set following two environmental variables
+# (case might be insensitive) as required by SOAP4R.
+#
+# --- soap_use_proxy
+#
+# Set the value of this variable to 'on'.
+#
+# --- http_proxy
+#
+# Set the URL of your proxy server (http://myproxy.com:8080 etc.).
+#
+# === Example to use HTTP proxy
+# 
+# % export soap_use_proxy=on
+# % export http_proxy=http://localhost:8080
+#
+class SOAPWSDL
+
+  # Returns URL of the current WSDL file.
+  attr_reader :wsdl
+
+  # Returns current logging IO.
+  attr_reader :log
+
+
+  def initialize(wsdl = nil)
+    @wsdl = wsdl
+    @log = nil
+    create_driver
+  end
+
+
+  def create_driver
+    if RUBY_VERSION > "1.8.2"
+      @driver = SOAP::WSDLDriverFactory.new(@wsdl).create_rpc_driver
+    else
+      @driver = SOAP::WSDLDriverFactory.new(@wsdl).create_driver
+    end
+    @driver.generate_explicit_type = true	# Ruby obj <-> SOAP obj
+  end
+  private :create_driver
+
+
+  # Change the URL for WSDL file
+  #
+  #   serv = Bio::SOAPWSDL.new("http://soap.genome.jp/KEGG.wsdl")
+  #
+  # or
+  # 
+  #   serv = Bio::SOAPWSDL.new
+  #   serv.wsdl = "http://soap.genome.jp/KEGG.wsdl"
+  #
+  # Note that you can't read two or more different WSDL files at once.
+  # In that case, create Bio::SOAPWSDL object for each.
+  #
+  def wsdl=(url)
+    @wsdl = url
+    create_driver
+  end
+
+
+  # Change the IO for logging.  The argument is passed to wiredump_dev method
+  # of the SOAP4R, thus
+  #
+  #   serv = Bio::SOAPWSDL.new
+  #   serv.log = STDERR
+  #
+  # will print all the SOAP transactions in standard error.
+  # This feature is especially useful for debug.
+  #
+  def log=(io)
+    @log = io
+    @driver.wiredump_dev = @log
+  end
+
+
+  # List of methods defined by WSDL
+  def list_methods
+    @driver.methods(false)
+  end
+
+
+  def method_missing(*arg)
+    @driver.send(*arg)
+  end
+  private :method_missing
+
+end # SOAPWSDL
+
+end # Bio
+

data/lib/bio/io/sql.rb

@@ -0,0 +1,186 @@
+
+require 'rubygems'
+require 'erb'
+require 'composite_primary_keys'
+# BiosqlPlug
+
+=begin
+Ok Hilmar gives to me some clarification
+1) "EMBL/GenBank/SwissProt" name in term table, is only a convention assuming data loaded by genbank embl ans swissprot formats.
+   If your features come from others ways for example blast or alignment ... whatever.. the user as to take care about the source. 
+
+
+=end
+=begin
+TODO:
+1) source_term_id => surce_term and check before if the source term is present or not and the level, the root should always be something "EMBL/GenBank/SwissProt" or contestualized.
+2) Into DummyBase class delete connection there and use Bio::ArSQL.establish_connection which reads info from a yml file. 
+3) Chk Locations in Biofeatures ArSQL
+=end
+module Bio
+  class SQL	
+    #no check is made
+    def self.establish_connection(configurations, env)
+      #configurations is an hash similar what YAML returns.
+      #{:database=>"biorails_development", :adapter=>"postgresql", :username=>"rails", :password=>nil}
+      configurations.assert_valid_keys('development', 'production','test')
+      configurations[env].assert_valid_keys('hostname','database','adapter','username','password')
+      DummyBase.configurations = configurations
+      DummyBase.establish_connection "#{env}"
+    end
+    
+    def self.fetch_id(id)
+      Bio::SQL::Bioentry.find(id)
+    end
+    
+    def self.fetch_accession(accession)
+      accession = accession.upcase
+      Bio::SQL::Bioentry.exists?(:accession => accession) ? Bio::SQL::Sequence.new(:entry=>Bio::SQL::Bioentry.find_by_accession(accession)) : nil			
+    end
+    
+    def self.exists_accession(accession)
+      Bio::SQL::Bioentry.find_by_accession(accession.upcase).nil? ? false : true
+    end
+    
+    def self.exists_database(name)
+      Bio::SQL::Biodatabase.find_by_name(name).nil? ? false : true
+    end
+    
+    def self.list_entries
+      Bio::SQL::Bioentry.find(:all).collect{|entry|
+        {:id=>entry.bioentry_id, :accession=>entry.accession}
+      }
+    end
+    
+    def self.list_databases
+      Bio::SQL::Biodatabase.find(:all).collect{|entry|
+        {:id=>entry.biodatabase_id, :name => entry.name}
+      }
+    end
+    
+    def self.delete_entry_id(id)
+      Bioentry.delete(id)
+    end
+    
+    def self.delete_entry_accession(accession)
+      Bioentry.delete(Bioentry.find_by_accession(accession))
+    end
+    
+    
+    class DummyBase <  ActiveRecord::Base
+      #NOTE: Using postgresql, not setting sequence name, system will discover the name by default.
+      #NOTE: this class will not establish the connection automatically
+      self.abstract_class = true			
+      self.pluralize_table_names = false
+      #prepend table name to the usual id, avoid to specify primary id for every table
+      self.primary_key_prefix_type = :table_name_with_underscore
+      #biosql_configurations=YAML::load(ERB.new(IO.read(File.join(File.dirname(__FILE__),'../config', 'database.yml'))).result)
+      #self.configurations=biosql_configurations
+      #self.establish_connection "development"
+    end #DummyBase
+    
+    autoload :Biodatabase, 'bio/io/biosql/biodatabase'
+    autoload :Bioentry, 'bio/io/biosql/bioentry'
+    autoload :BioentryDbxref, 'bio/io/biosql/bioentry_dbxref'
+    autoload :BioentryPath, 'bio/io/biosql/bioentry_path'
+    autoload :BioentryQualifierValue, 'bio/io/biosql/bioentry_qualifier_value'
+    autoload :BioentryReference, 'bio/io/biosql/bioentry_reference'
+    autoload :BioentryRelationship, 'bio/io/biosql/bioentry_relationship'
+    autoload :Biosequence, 'bio/io/biosql/biosequence'
+    autoload :Comment, 'bio/io/biosql/comment'
+    autoload :Dbxref, 'bio/io/biosql/dbxref'
+    autoload :DbxrefQualifierValue, 'bio/io/biosql/dbxref_qualifier_value'
+    autoload :Location, 'bio/io/biosql/location'
+    autoload :LocationQualifierValue, 'bio/io/biosql/location_qualifier_value'
+    autoload :Ontology, 'bio/io/biosql/ontology'
+    autoload :Reference, 'bio/io/biosql/reference'
+    autoload :Seqfeature, 'bio/io/biosql/seqfeature'
+    autoload :SeqfeatureDbxref, 'bio/io/biosql/seqfeature_dbxref'
+    autoload :SeqfeaturePath, 'bio/io/biosql/seqfeature_path'
+    autoload :SeqfeatureQualifierValue, 'bio/io/biosql/seqfeature_qualifier_value'
+    autoload :SeqfeatureRelationship, 'bio/io/biosql/seqfeature_relationship'
+    autoload :Taxon, 'bio/io/biosql/taxon'
+    autoload :TaxonName, 'bio/io/biosql/taxon_name'
+    autoload :Term, 'bio/io/biosql/term'
+    autoload :TermDbxref, 'bio/io/biosql/term_dbxref'
+    autoload :TermPath, 'bio/io/biosql/term_path'
+    autoload :TermRelationship, 'bio/io/biosql/term_relationship'
+    autoload :TermRelationshipTerm, 'bio/io/biosql/term_relationship_term'
+    autoload :Sequence, 'bio/db/biosql/sequence'
+  end #biosql
+  
+end #Bio
+
+if __FILE__ == $0
+  require 'rubygems'
+  require 'composite_primary_keys'
+  require 'bio'
+  require 'pp'
+  
+  #  pp connection = Bio::SQL.establish_connection('bio/io/biosql/config/database.yml','development')
+  connection = Bio::SQL.establish_connection({'development'=>{'database'=>"bio_test", 'adapter'=>"postgresql", 'username'=>"rails", 'password'=>nil}},'development')
+  #pp YAML::load(ERB.new(IO.read('bio/io/biosql/config/database.yml')).result)
+  if true
+    #Bio::SQL.list_entries
+
+#  	biosequence = data.to_biosequence
+#	puts biosequence.output(:genbank)
+	db=Bio::SQL::Biodatabase.new(:name=>'JEFF', :authority=>'ME', :description=>'YOU')
+	db.save!
+
+    puts "### FileFile.auto"
+    if ARGV.size > 0
+	#embl = Bio::FlatFile.auto(ARGF.read)
+	Bio::FlatFile.auto(ARGF) do |ff|
+		ff.each do |data|
+			biosequence=data.to_biosequence
+			puts biosequence.output(:fasta)
+			sqlseq = Bio::SQL::Sequence.new(:biosequence=>biosequence,:biodatabase_id=>db.biodatabase_id)
+			sqlseq.save
+			sqlseq.to_biosequence.output(:fasta)
+		end
+	end
+    else
+	require 'bio/io/fetch'
+	server = Bio::Fetch.new('http://www.ebi.ac.uk/cgi-bin/dbfetch')
+	data = Bio::EMBL.new(server.fetch('embl','AJ224123'))
+    end
+
+	
+#	sqlseq = Bio::SQL::Sequence.new(:biosequence=>biosequence,:biodatabase_id=>db.biodatabase_id)
+#	sqlseq.save
+#	sqlseq_bioseq=sqlseq.to_biosequence	
+#	puts sqlseq_bioseq.output(:genbank)
+
+
+
+	#    bioseq = Bio::SQL.fetch_accession('AJ224122')   
+	#    pp bioseq
+	#    pp bioseq.entry_id    
+    #TODO create a test only for tables not sequence here
+#    pp bioseq.molecule_type
+    #pp  bioseq.molecule_type.class
+    #bioseq.molecule_type_update('dna', 1)
+##    pp Bio::SQL::Taxon.find(8121).taxon_names
+    
+	    #sqlseq.to_biosequence
+	
+#	sqlseq.delete
+	
+#	db.destroy
+  end
+  #pp  bioseq.molecule_type
+  #term = Bio::SQL::Term.find_by_name('mol_type')
+  #pp term
+  #pp bioseq.entry.bioentry_qualifier_values.create(:term=>term, :rank=>2, :value=>'pippo')
+  #pp bioseq.entry.bioentry_qualifier_values.inspect
+  #pp bioseq.entry.bioentry_qualifier_values.find_all_by_term_id(26)
+  #pp primo.class
+  #  pp primo.value='dna'
+  #  pp primo.save
+  #pp bioseq.molecule_type= 'prova'
+  
+  #Bio::SQL::BioentryQualifierValue.delete(delete.bioentry_id,delete.term_id,delete.rank)
+  
+  
+end