bio 1.3.0 → 1.3.1

data/lib/bio/db/embl/embl.rb

@@ -448,9 +448,6 @@ class EMBL < EMBLDB
   # taxonomy classfication
   alias classification oc
 
-  # features
-  alias features ft
-
 
   # converts the entry to Bio::Sequence object
   # ---

data/lib/bio/db/genbank/common.rb

@@ -158,7 +158,9 @@ module Common
             authors = authors.flatten.map { |a| a.sub(/,/, ', ') }
             hash['authors']	= authors
           when /TITLE/
-            hash['title']	= truncate(tag_cut(field)) + '.'
+            hash['title']	= truncate(tag_cut(field))
+            # CHECK Actually GenBank is not demanding for dot at the end of TITLE
+            #+ '.'
           when /JOURNAL/
             journal = truncate(tag_cut(field))
             if journal =~ /(.*) (\d+) \((\d+)\), (\d+-\d+) \((\d+)\)$/

data/lib/bio/io/biosql/ar-biosql.rb

@@ -0,0 +1,257 @@
+module Bio
+  class SQL
+    class Biodatabase < DummyBase
+      has_many :bioentries, :class_name =>"Bioentry", :foreign_key => "biodatabase_id"
+      validates_uniqueness_of :name
+    end
+    class BioentryDbxref < DummyBase
+      #delete				set_sequence_name nil
+      set_primary_key nil #bioentry_id,dbxref_id
+      belongs_to :bioentry, :class_name => "Bioentry"
+      belongs_to :dbxref, :class_name => "Dbxref"
+    end
+
+    class BioentryPath < DummyBase
+      set_primary_key nil
+      #delete				set_sequence_name nil
+      belongs_to :term, :class_name => "Term"
+      #da sistemare per poter procedere.
+      belongs_to :object_bioentry, :class_name=>"Bioentry"
+      belongs_to :subject_bioentry, :class_name=>"Bioentry"
+    end #BioentryPath
+
+    class BioentryQualifierValue < DummyBase
+      #NOTE: added rank to primary_keys, now it's finished.
+      set_primary_keys :bioentry_id, :term_id, :rank
+      belongs_to :bioentry, :class_name => "Bioentry"
+      belongs_to :term, :class_name => "Term"
+    end #BioentryQualifierValue
+  
+    class Bioentry < DummyBase
+      belongs_to :biodatabase, :class_name => "Biodatabase"
+      belongs_to :taxon, :class_name => "Taxon"
+      has_one :biosequence
+      #, :class_name => "Biosequence", :foreign_key => "bioentry_id"
+      has_many :comments, :class_name =>"Comment", :order =>'rank'
+      has_many :seqfeatures, :class_name => "Seqfeature", :order=>'rank'
+      has_many :bioentry_references, :class_name=>"BioentryReference" #, :foreign_key => "bioentry_id"
+      has_many :bioentry_dbxrefs, :class_name => "BioentryDbxref"
+      has_many :object_bioentry_relationships, :class_name=>"BioentryRelationship", :foreign_key=>"object_bioentry_id" #non mi convince molto credo non funzioni nel modo corretto
+      has_many :subject_bioentry_relationships, :class_name=>"BioentryRelationship", :foreign_key=>"subject_bioentry_id" #non mi convince molto credo non funzioni nel modo corretto
+      has_many :object_bioentry_paths, :class_name=>"BioentryPath", :foreign_key=>"object_bioentry_id" #non mi convince molto credo non funzioni nel modo corretto
+      has_many :subject_bioentry_paths, :class_name=>"BioentryPath", :foreign_key=>"subject_bioentry_id" #non mi convince molto credo non funzioni nel modo corretto
+
+      has_many :cdsfeatures, :class_name=>"Seqfeature", :foreign_key =>"bioentry_id", :conditions=>["term.name='CDS'"], :include=>"type_term"
+      has_many :references, :through=>:bioentry_references, :class_name => "Reference"
+      has_many :terms, :through=>:bioentry_qualifier_values, :class_name => "Term"
+      #NOTE: added order_by for multiple hit and manage ranks correctly
+      has_many :bioentry_qualifier_values, :order=>"bioentry_id,term_id,rank", :class_name => "BioentryQualifierValue"
+        
+      #per la creazione richiesti:
+      #name, accession, version
+      #				validates_uniqueness_of :accession, :scope=>[:biodatabase_id]
+      #				validates_uniqueness_of :name, :scope=>[:biodatabase_id]
+			#	validates_uniqueness_of :identifier, :scope=>[:biodatabase_id]
+				
+    end
+    class BioentryReference < DummyBase
+      set_primary_keys :bioentry_id, :reference_id, :rank
+      belongs_to :bioentry, :class_name => "Bioentry"
+      belongs_to :reference , :class_name => "Reference"
+    end
+    class BioentryRelationship < DummyBase
+      #delete				set_primary_key "bioentry_relationship_id"
+      set_sequence_name "bieontry_relationship_pk_seq"
+      belongs_to :object_bioentry, :class_name => "Bioentry"
+      belongs_to :subject_bioentry, :class_name => "Bioentry"
+      belongs_to :term
+    end
+    class Biosequence < DummyBase
+      set_primary_keys :bioentry_id, :version
+      #delete				set_sequence_name "biosequence_pk_seq"
+      belongs_to :bioentry, :foreign_key=>"bioentry_id"
+      #has_one :bioentry
+      #, :class_name => "Bioentry"
+    end
+    class Comment < DummyBase
+      belongs_to :bioentry, :class_name => "Bioentry"
+    end
+    class DbxrefQualifierValue < DummyBase
+      #think to use composite primary key
+      set_primary_key nil #dbxref_id, term_id, rank
+      #delete			      set_sequence_name nil
+      belongs_to :dbxref, :class_name => "Dbxref"
+      belongs_to :term, :class_name => "Term"
+    end
+    class Dbxref < DummyBase
+      #set_sequence_name "dbxref_pk_seq"
+      has_many :dbxref_qualifier_values, :class_name => "DbxrefQualifierValue"
+      has_many :locations, :class_name => "Location"
+      has_many :references, :class_name=>"Reference"
+      has_many :term_dbxrefs, :class_name => "TermDbxref"
+      has_many :bioentry_dbxrefs, :class_name => "BioentryDbxref"
+      #TODO: check is with bioentry there is an has_and_belongs_to_many relationship has specified in schema overview.
+    end
+    class LocationQualifierValue <  DummyBase
+      set_primary_key nil #location_id, term_id
+      #delete			      set_sequence_name nil
+      belongs_to :location, :class_name => "Location"
+      belongs_to :term, :class_name => "Term"
+    end
+    class Location < DummyBase
+      #set_sequence_name "location_pk_seq"
+      belongs_to :seqfeature, :class_name => "Seqfeature"
+      belongs_to :dbxref, :class_name => "Dbxref"
+      belongs_to :term, :class_name => "Term"
+      has_many :location_qualifier_values, :class_name => "LocationQualifierValue"
+      
+      def to_s
+        if strand==-1
+          str="complement("+start_pos.to_s+".."+end_pos.to_s+")"
+        else
+          str=start_pos.to_s+".."+end_pos.to_s
+        end
+        return str    
+      end
+      
+      def sequence
+        seq=""
+        unless self.seqfeature.bioentry.biosequence.seq.nil?
+          seq=Bio::Sequence::NA.new(self.seqfeature.bioentry.biosequence.seq[start_pos-1..end_pos-1])
+          seq.reverse_complement! if strand==-1
+        end
+        return seq        
+      end
+      
+      
+      
+    end
+    class Ontology < DummyBase
+      has_many :terms, :class_name => "Term"
+      has_many :term_paths, :class_name => "TermPath"
+      has_many :term_relationships, :class_name => "TermRelationship"
+    end
+    class Reference < DummyBase
+      belongs_to :dbxref, :class_name => "Dbxref"
+      has_many :bioentry_references, :class_name=>"BioentryReference"
+      has_many :bioentries, :through=>:bioentry_references
+    end
+    class SeqfeatureDbxref < DummyBase
+      set_primary_keys :seqfeature_id, :dbxref_id
+      #delete		      set_sequence_name nil
+      belongs_to :seqfeature, :class_name => "Seqfeature", :foreign_key => "seqfeature_id"
+      belongs_to :dbxref, :class_name => "Dbxref", :foreign_key => "dbxref_id"
+    end
+    class SeqfeaturePath < DummyBase
+      set_primary_keys :object_seqfeature_id, :subject_seqfeature_id, :term_id
+      set_sequence_name nil
+      belongs_to :object_seqfeature, :class_name => "Seqfeature", :foreign_key => "object_seqfeature_id"
+      belongs_to :subject_seqfeature, :class_name => "Seqfeature", :foreign_key => "subject_seqfeature_id"
+      belongs_to :term, :class_name => "Term"
+    end
+    class SeqfeatureQualifierValue < DummyBase
+      set_primary_keys  :seqfeature_id, :term_id, :rank
+      set_sequence_name nil
+      belongs_to :seqfeature
+      belongs_to :term, :class_name => "Term"
+    end		
+    class Seqfeature <DummyBase  
+      set_sequence_name "seqfeature_pk_seq"
+      belongs_to :bioentry
+      #, :class_name => "Bioentry"
+      belongs_to :type_term, :class_name => "Term", :foreign_key => "type_term_id"
+      belongs_to :source_term, :class_name => "Term", :foreign_key =>"source_term_id"
+      has_many :seqfeature_dbxrefs, :class_name => "SeqfeatureDbxref", :foreign_key => "seqfeature_id"
+      has_many :seqfeature_qualifier_values, :order=>'rank', :foreign_key => "seqfeature_id"
+      #, :class_name => "SeqfeatureQualifierValue"
+      has_many :locations, :class_name => "Location", :order=>'rank'
+      has_many :object_seqfeature_paths, :class_name => "SeqfeaturePath", :foreign_key => "object_seqfeature_id"
+      has_many :subject_seqfeature_paths, :class_name => "SeqfeaturePath", :foreign_key => "subject_seqfeature_id"
+      has_many :object_seqfeature_relationships, :class_name => "SeqfeatureRelationship", :foreign_key => "object_seqfeature_id"
+      has_many :subject_seqfeature_relationships, :class_name => "SeqfeatureRelationship", :foreign_key => "subject_seqfeature_id"
+
+      #get the subsequence described by the locations objects
+      def sequence
+        return self.locations.inject(Bio::Sequence::NA.new("")){|seq, location| seq<<location.sequence}
+      end
+    
+      #translate the subsequences represented by the feature and its locations
+      #not considering the qualifiers 
+      #Return a Bio::Sequence::AA object
+      def translate(*args)
+        self.sequence.translate(*args)
+      end
+    end
+    class SeqfeatureRelationship <DummyBase
+      set_sequence_name "seqfeatue_relationship_pk_seq"
+      belongs_to :term, :class_name => "Term"
+      belongs_to :object_seqfeature, :class_name => "Seqfeature"
+      belongs_to :subject_seqfeature, :class_name => "Seqfeature"
+    end
+    class TaxonName < DummyBase
+      set_primary_keys :taxon_id, :name, :name_class
+      belongs_to :taxon, :class_name => "Taxon"
+    end
+    class Taxon < DummyBase
+      set_sequence_name "taxon_pk_seq"
+      has_many :taxon_names, :class_name => "TaxonName"
+      has_one :taxon_scientific_name, :class_name => "TaxonName", :conditions=>"name_class = 'scientific name'"
+      has_one :taxon_genbank_common_name, :class_name => "TaxonName", :conditions=>"name_class = 'genbank common name'"
+      has_one :bioentry, :class_name => "Bioentry"
+    end
+    class TermDbxref < DummyBase
+      set_primary_key nil #term_id, dbxref_id
+      #delete			      set_sequence_name nil
+      belongs_to :term, :class_name => "Term"
+      belongs_to :dbxref, :class_name => "Dbxref"
+    end
+    class TermPath < DummyBase
+      set_sequence_name "term_path_pk_seq"
+      belongs_to :ontology, :class_name => "Ontology"
+      belongs_to :subject_term, :class_name => "Term"
+      belongs_to :object_term, :class_name => "Term"
+      belongs_to :predicate_term, :class_name => "Term"
+    end
+    class Term < DummyBase
+      belongs_to :ontology, :class_name => "Ontology"
+      has_many :seqfeature_qualifier_values, :class_name => "SeqfeatureQualifierValue"
+      has_many :dbxref_qualifier_values, :class_name => "DbxrefQualifierValue"
+      has_many :bioentry_qualifer_values, :class_name => "BioentryQualifierValue"
+      has_many :bioentries, :through=>:bioentry_qualifier_values
+      has_many :locations, :class_name => "Location"
+      has_many :seqfeature_relationships, :class_name => "SeqfeatureRelationship"
+      has_many :term_dbxrefs, :class_name => "TermDbxref"
+      has_many :term_relationship_terms, :class_name => "TermRelationshipTerm"
+      has_many :term_synonyms, :class_name => "TermSynonym"
+      has_many :location_qualifier_values, :class_name => "LocationQualifierValue"
+      has_many :seqfeature_types, :class_name => "Seqfeature", :foreign_key => "type_term_id"
+      has_many :seqfeature_sources, :class_name => "Seqfeature", :foreign_key => "source_term_id"
+      has_many :term_path_subjects, :class_name => "TermPath", :foreign_key => "subject_term_id"
+      has_many :term_path_predicates, :class_name => "TermPath", :foreign_key => "predicate_term_id"
+      has_many :term_path_objects, :class_name => "TermPath", :foreign_key => "object_term_id"
+      has_many :term_relationship_subjects, :class_name => "TermRelationship", :foreign_key =>"subject_term_id"
+      has_many :term_relationship_predicates, :class_name => "TermRelationship", :foreign_key =>"predicate_term_id"
+      has_many :term_relationship_objects, :class_name => "TermRelationship", :foreign_key =>"object_term_id"
+      has_many :seqfeature_paths, :class_name => "SeqfeaturePath"
+    end
+    class TermRelationship < DummyBase
+      set_sequence_name "term_relationship_pk_seq"
+      belongs_to :ontology, :class_name => "Ontology"
+      belongs_to :subject_term, :class_name => "Term"
+      belongs_to :predicate_term, :class_name => "Term"
+      belongs_to :object_term, :class_name => "Term"
+      has_one :term_relationship_term, :class_name => "TermRelationshipTerm"
+    end
+    class TermRelationshipTerm < DummyBase
+      #delete			      set_sequence_name nil
+      set_primary_key :term_relationship_id
+      belongs_to :term_relationship, :class_name => "TermRelationship"
+      belongs_to :term, :class_name => "Term"
+    end
+    class TermSynonym < DummyBase
+      #delete			      set_sequence_name nil
+      set_primary_key nil
+      belongs_to :term, :class_name => "Term"
+    end
+  end #SQL
+end #Bio

data/lib/bio/io/biosql/biosql.rb

@@ -0,0 +1,39 @@
+#require 'dm-ar-finders'
+#require 'dm-core'
+require 'erb'
+require 'composite_primary_keys'
+
+module Bio
+ class SQL
+    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
+
+    require 'bio/io/biosql/ar-biosql'
+    
+  #  #no check is made
+  def self.establish_connection(configurations, env)
+    #  #configurations is an hash similar what YAML returns.
+
+     #configurations.assert_valid_keys('development', 'production','test')
+     #configurations[env].assert_valid_keys('hostname','database','adapter','username','password')
+     DummyBase.configurations = configurations
+    connection = DummyBase.establish_connection "#{env}"
+    #Init of basis terms and ontologies
+    Ontology.first(:conditions => ["name = ?", 'Annotation Tags']) || Ontology.create({:name => 'Annotation Tags'})
+    Ontology.first(:conditions => ["name = ?", 'SeqFeature Keys']) || Ontology.create({:name => 'SeqFeature Keys'})
+    Ontology.first(:conditions => ["name = ?", 'SeqFeature Sources']) ||Ontology.create({:name => 'SeqFeature Sources'})
+    Term.first(:conditions => ["name = ?", 'EMBLGenBankSwit']) || Term.create({:name => 'EMBLGenBankSwit', :ontology => Ontology.first(:conditions => ["name = ?", 'SeqFeature Sources'])})
+    connection 
+  end #establish_connection
+  
+  end #SQL
+end #Bio

data/lib/bio/io/biosql/config/database.yml

@@ -2,10 +2,11 @@
 #User can configure it's db here
 
 development:
-  adapter: postgresql
-  database: biorails_development
-  username: rails
-  password: 
+  adapter: jdbcmysql
+  database: bioseq
+  username: febo
+  password:
+  hostname: localhost
 
 test:
   adapter: postgresql

data/lib/bio/io/ncbirest.rb

@@ -26,8 +26,10 @@ class REST
   # weekdays for any series of more than 100 requests.
   # -> Not implemented yet in BioRuby
 
-  # Make no more than one request every 3 seconds.
-  NCBI_INTERVAL = 3
+  # Make no more than one request every 1 seconds.
+  # (NCBI's restriction is "Make no more than 3 requests every 1 second.",
+  # but limited to 1/sec partly because of keeping the value in integer.)
+  NCBI_INTERVAL = 1
   @@last_access = nil
 
   private
@@ -127,10 +129,10 @@ class REST
   #   * _mindate_: 2001
   #   * _maxdate_: 2002/01/01
   #   * _datetype_: "edat"
-  # * _limit_: maximum number of entries to be returned (0 for unlimited)
+  # * _limit_: maximum number of entries to be returned (0 for unlimited; nil for the "retmax" value in the hash or the internal default value (=100))
   # * _step_: maximum number of entries retrieved at a time
   # *Returns*:: array of entry IDs or a number of results
-  def esearch(str, hash = {}, limit = 100, step = 10000)
+  def esearch(str, hash = {}, limit = nil, step = 10000)
     serv = "http://eutils.ncbi.nlm.nih.gov/entrez/eutils/esearch.fcgi"
     opts = {
       "tool"   => "bioruby",
@@ -143,12 +145,17 @@ class REST
       count = esearch_count(str, opts)
       return count
     else
+      retstart = 0
+      retstart = hash["retstart"].to_i if hash["retstart"]
+
+      limit ||= hash["retmax"].to_i if hash["retmax"]
+      limit ||= 100 # default limit is 100
       limit = esearch_count(str, opts) if limit == 0   # unlimit
 
       list = []
       0.step(limit, step) do |i|
         retmax = [step, limit - i].min
-        opts.update("retmax" => retmax, "retstart" => i)
+        opts.update("retmax" => retmax, "retstart" => i + retstart)
         ncbi_access_wait
         response = Bio::Command.post_form(serv, opts)
         result = response.body

data/lib/bio/io/pubmed.rb

@@ -117,7 +117,11 @@ class PubMed < Bio::NCBI::REST
   def efetch(ids, hash = {})
     opts = { "db" => "pubmed", "rettype"  => "medline" }
     opts.update(hash)
-    super(ids, opts)
+    result = super(ids, opts)
+    if !opts["retmode"] or opts["retmode"] == "text"
+      result = result.split(/\n\n+/)
+    end
+    result
   end
 
   # Search the PubMed database by given keywords using entrez query and returns

data/lib/bio/io/sql.rb

@@ -1,186 +1,79 @@
+#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
 
-require 'rubygems'
-require 'erb'
-require 'composite_primary_keys'
+
+#require 'rubygems'
+#require 'composite_primary_keys'
+#require 'erb'
 # 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. 
+   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. 
+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
-    
+  class SQL
+
+    require 'bio/io/biosql/biosql'
+    autoload :Sequence, 'bio/db/biosql/sequence'
+
     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			
+#     Bio::SQL::Bioentry.exists?(:accession => accession) ? Bio::SQL::Sequence.new(:entry=>Bio::SQL::Bioentry.find_by_accession(accession)) : nil
+      Bio::SQL::Sequence.new(:entry=>Bio::SQL::Bioentry.find_by_accession(accession.upcase))
     end
-    
+
     def self.exists_accession(accession)
-      Bio::SQL::Bioentry.find_by_accession(accession.upcase).nil? ? false : true
+#      Bio::SQL::Bioentry.find_by_accession(accession.upcase).nil? ? false : true
+      !Bio::SQL::Bioentry.find_by_accession(accession.upcase).nil?
     end
-    
+
     def self.exists_database(name)
-      Bio::SQL::Biodatabase.find_by_name(name).nil? ? false : true
+#      Bio::SQL::Biodatabase.find_by_name(name).nil? ? false : true
+      !Bio::SQL::Biodatabase.first(:name=>name).nil?
     end
-    
+
     def self.list_entries
-      Bio::SQL::Bioentry.find(:all).collect{|entry|
+      Bio::SQL::Bioentry.all.collect do|entry|
         {:id=>entry.bioentry_id, :accession=>entry.accession}
-      }
+      end
     end
-    
+
     def self.list_databases
-      Bio::SQL::Biodatabase.find(:all).collect{|entry|
+      Bio::SQL::Biodatabase.all.collect do|entry|
         {:id=>entry.biodatabase_id, :name => entry.name}
-      }
+      end
     end
-    
+
     def self.delete_entry_id(id)
-      Bioentry.delete(id)
+      Bio::SQL::Bioentry.delete(id)
     end
-    
+
     def self.delete_entry_accession(accession)
-      Bioentry.delete(Bioentry.find_by_accession(accession))
+      Bio::SQL::Bioentry.find_by_accession(accession.upcase).destroy!
     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
+  end #biosql
 
-	
-#	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
+end #Bio