bio 1.3.1 → 1.4.0

data/lib/bio/db/fastq/fastq_to_biosequence.rb

@@ -0,0 +1,40 @@
+#
+# = bio/db/fastq/fastq_to_biosequence.rb - Bio::Fastq to Bio::Sequence adapter module
+#
+# Copyright::   Copyright (C) 2009
+#               Naohisa Goto <ng@bioruby.org>
+# License::     The Ruby License
+#
+
+require 'bio/sequence'
+require 'bio/sequence/adapter'
+
+# Internal use only. Normal users should not use this module.
+#
+# Bio::Fastq to Bio::Sequence adapter module.
+# It is internally used in Bio::Fastq#to_biosequence.
+#
+module Bio::Sequence::Adapter::Fastq
+
+  extend Bio::Sequence::Adapter
+
+  private
+
+  def_biosequence_adapter :seq
+
+  def_biosequence_adapter :entry_id
+
+  # primary accession
+  def_biosequence_adapter :primary_accession do |orig|
+    orig.entry_id
+  end
+
+  def_biosequence_adapter :definition
+
+  def_biosequence_adapter :quality_scores
+
+  def_biosequence_adapter :quality_score_type
+
+  def_biosequence_adapter :error_probabilities
+
+end #module Bio::Sequence::Adapter::Fastq

data/lib/bio/db/fastq/format_fastq.rb

@@ -0,0 +1,175 @@
+#
+# = bio/db/fasta/format_fastq.rb - FASTQ format generater
+#
+# Copyright::   Copyright (C) 2009
+#               Naohisa Goto <ng@bioruby.org>
+# License::    The Ruby License
+#
+
+require 'bio/db/fastq'
+require 'bio/sequence/format'
+
+module Bio::Sequence::Format::Formatter
+
+  # INTERNAL USE ONLY, YOU SHOULD NOT USE THIS CLASS.
+  #
+  # FASTQ format output class for Bio::Sequence.
+  #
+  # The default FASTQ format is fastq-sanger.
+  class Fastq < Bio::Sequence::Format::FormatterBase
+
+    # INTERNAL USE ONLY, YOU SHOULD NOT CALL THIS METHOD.
+    #
+    # Creates a new Fasta format generater object from the sequence.
+    #
+    # ---
+    # *Arguments*:
+    # * _sequence_: Bio::Sequence object
+    # * (optional) :repeat_title => (true or false) if true, repeating title in the "+" line; if not true, "+" only (default false)
+    # * (optional) :width => _width_: (Fixnum) width to wrap sequence and quality lines;  nil to prevent wrapping (default 70)
+    # * (optional) :title => _title_: (String) completely replaces title line with the _title_ (default nil)
+    # * (optional) :default_score => _score_: (Integer) default score for bases that have no valid quality scores or error probabilities; false or nil means the lowest score, true means the highest score (default nil)
+    def initialize; end if false # dummy for RDoc
+
+    # INTERNAL USE ONLY, YOU SHOULD NOT CALL THIS METHOD.
+    #
+    # Output the FASTQ format string of the sequence.  
+    #
+    # Currently, this method is used in Bio::Sequence#output like so,
+    #
+    #   s = Bio::Sequence.new('atgc')
+    #   puts s.output(:fastq_sanger)
+    # ---
+    # *Returns*:: String object
+    def output
+      title = @options[:title]
+      width = @options.has_key?(:width) ? @options[:width] : 70
+      seq = @sequence.seq.to_s
+      entry_id = @sequence.entry_id || 
+        "#{@sequence.primary_accession}.#{@sequence.sequence_version}"
+      definition = @sequence.definition
+      unless title then
+        title = definition.to_s
+        unless title[0, entry_id.length] == entry_id and
+            /\s/ =~ title[entry_id.length, 1].to_s then
+          title = "#{entry_id} #{title}"
+        end
+      end
+      title2 = @options[:repeat_title] ? title : ''
+      qstr = fastq_quality_string(seq, @options[:default_score])
+
+      "@#{title}\n" +
+        if width then
+          seq.gsub(Regexp.new(".{1,#{width}}"), "\\0\n")
+        else
+          seq + "\n"
+        end +
+        "+#{title2}\n" +
+        if width then
+          qstr.gsub(Regexp.new(".{1,#{width}}"), "\\0\n")
+        else
+          qstr + "\n"
+        end
+    end
+
+    private
+    def fastq_format_data
+      Bio::Fastq::FormatData::FASTQ_SANGER.instance
+    end
+
+    def fastq_quality_string(seq, default_score)
+      sc = fastq_quality_scores(seq)
+      if sc.size < seq.length then
+        if default_score == true then
+          # when true, the highest score
+          default_score = fastq_format_data.score_range.end
+        else
+          # when false or nil, the lowest score
+          default_score ||= fastq_format_data.score_range.begin
+        end
+        sc = sc + ([ default_score ] * (seq.length - sc.size))
+      end
+      fastq_format_data.scores2str(sc)
+    end
+
+    def fastq_quality_scores(seq)
+      return [] if seq.length <= 0
+      fmt = fastq_format_data
+      # checks quality_scores
+      qsc = @sequence.quality_scores
+      qsc_type = @sequence.quality_score_type
+      if qsc and qsc_type and
+          qsc_type == fmt.quality_score_type and
+          qsc.size >= seq.length then
+        return qsc
+      end
+      
+      # checks error_probabilities
+      ep = @sequence.error_probabilities
+      if ep and ep.size >= seq.length then
+        return fmt.p2q(ep[0, seq.length])
+      end
+
+      # If quality score type of the sequence is nil, regarded as :phred.
+      qsc_type ||= :phred
+
+      # checks if scores can be converted
+      if qsc and qsc.size >= seq.length then
+        case [ qsc_type, fmt.quality_score_type ]
+        when [ :phred, :solexa ]
+          return fmt.convert_scores_from_phred_to_solexa(qsc[0, seq.length])
+        when [ :solexa, :phred ]
+          return fmt.convert_scores_from_solexa_to_phred(qsc[0, seq.length])
+        end
+      end
+
+      # checks quality scores type
+      case qsc_type
+      when :phred, :solexa
+        #does nothing
+      else
+        qsc_type = nil
+        qsc = nil
+      end
+
+      # collects piece of information
+      qsc_cov = qsc ? qsc.size.quo(seq.length) : 0
+      ep_cov = ep ? ep.size.quo(seq.length) : 0
+      if qsc_cov > ep_cov then
+        case [ qsc_type, fmt.quality_score_type ]
+        when [ :phred, :phred ], [ :solexa, :solexa ]
+          return qsc
+        when [ :phred, :solexa ]
+          return fmt.convert_scores_from_phred_to_solexa(qsc)
+        when [ :solexa, :phred ]
+          return fmt.convert_scores_from_solexa_to_phred(qsc)
+        end
+      elsif ep_cov > qsc_cov then
+        return fmt.p2q(ep)
+      end
+
+      # if no information, returns empty array
+      return []
+    end
+  end #class Fastq
+
+  # class Fastq_sanger is the same as the Fastq class.
+  Fastq_sanger = Fastq
+
+  class Fastq_solexa < Fastq
+    private
+    def fastq_format_data
+      Bio::Fastq::FormatData::FASTQ_SOLEXA.instance
+    end
+  end #class Fastq_solexa
+
+  class Fastq_illumina < Fastq
+    private
+    def fastq_format_data
+      Bio::Fastq::FormatData::FASTQ_ILLUMINA.instance
+    end
+  end #class Fastq_illumina
+
+end #module Bio::Sequence::Format::Formatter
+
+

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

@@ -4,7 +4,7 @@
 # Copyright::  Copyright (C) 2000-2005 Toshiaki Katayama <k@bioruby.org>
 # License::    The Ruby License
 #
-# $Id: genbank.rb,v 0.40.2.4 2008/06/17 15:56:18 ngoto Exp $
+# $Id:$
 #
 
 require 'date'
@@ -163,88 +163,3 @@ class GenBank < NCBIDB
 end # GenBank
 end # Bio
 
-
-
-if __FILE__ == $0
-
-  begin
-    require 'pp'
-    alias p pp
-  rescue LoadError
-  end
-
-  puts "### GenBank"
-  if ARGV.size > 0
-    gb = Bio::GenBank.new(ARGF.read)
-  else
-    require 'bio/io/fetch'
-    gb = Bio::GenBank.new(Bio::Fetch.query('gb', 'LPATOVGNS'))
-  end
-
-  puts "## LOCUS"
-  puts "# GenBank.locus"
-  p gb.locus
-  puts "# GenBank.entry_id"
-  p gb.entry_id
-  puts "# GenBank.nalen"
-  p gb.nalen
-  puts "# GenBank.strand"
-  p gb.strand
-  puts "# GenBank.natype"
-  p gb.natype
-  puts "# GenBank.circular"
-  p gb.circular
-  puts "# GenBank.division"
-  p gb.division
-  puts "# GenBank.date"
-  p gb.date
-
-  puts "## DEFINITION"
-  p gb.definition
-
-  puts "## ACCESSION"
-  p gb.accession
-
-  puts "## VERSION"
-  p gb.versions
-  p gb.version
-  p gb.gi
-
-  puts "## NID"
-  p gb.nid
-
-  puts "## KEYWORDS"
-  p gb.keywords
-
-  puts "## SEGMENT"
-  p gb.segment
-
-  puts "## SOURCE"
-  p gb.source
-  p gb.common_name
-  p gb.vernacular_name
-  p gb.organism
-  p gb.taxonomy
-
-  puts "## REFERENCE"
-  p gb.references
-
-  puts "## COMMENT"
-  p gb.comment
-
-  puts "## FEATURES"
-  p gb.features
-
-  puts "## BASE COUNT"
-  p gb.basecount
-  p gb.basecount('a')
-  p gb.basecount('A')
-
-  puts "## ORIGIN"
-  p gb.origin
-  p gb.naseq
-
-end
-
-
-

data/lib/bio/db/gff.rb

@@ -1827,20 +1827,3 @@ module Bio
 
 end # module Bio
 
-
-if __FILE__ == $0
-  begin
-    require 'pp'
-    alias p pp
-  rescue LoadError
-  end
-
-  this_gff =  "SEQ1\tEMBL\tatg\t103\t105\t.\t+\t0\n"
-  this_gff << "SEQ1\tEMBL\texon\t103\t172\t.\t+\t0\n"
-  this_gff << "SEQ1\tEMBL\tsplice5\t172\t173\t.\t+\t.\n"
-  this_gff << "SEQ1\tnetgene\tsplice5\t172\t173\t0.94\t+\t.\n"
-  this_gff << "SEQ1\tgenie\tsp5-20\t163\t182\t2.3\t+\t.\n"
-  this_gff << "SEQ1\tgenie\tsp5-10\t168\t177\t2.1\t+\t.\n"
-  this_gff << "SEQ1\tgrail\tATG\t17\t19\t2.1\t-\t0\n"
-  p Bio::GFF.new(this_gff)
-end

data/lib/bio/db/go.rb

@@ -5,7 +5,7 @@
 #               Mitsuteru C. Nakao <n@bioruby.org>
 # License::     The Ruby License
 #
-#  $Id: go.rb,v 1.11 2007/04/05 23:35:40 trevor Exp $
+#  $Id:$
 #
 # == Gene Ontology
 #
@@ -89,7 +89,7 @@ class GO
       stack    = []
       adj_list = []
       
-      str.each {|line|
+      str.each_line {|line|
         if /^!(.+?):\s+(\S.+)$/ =~ line  # Parsing head lines
           tag   = $1
           value = $2
@@ -198,13 +198,13 @@ class GO
     # Block is acceptable.  
     def self.parser(str)
       if block_given?
-        str.each(DELIMITER) {|line|
+        str.each_line(DELIMITER) {|line|
           next if /^!/ =~ line
           yield GeneAssociation.new(line)
         }
       else
         galist = []
-        str.each(DELIMITER) {|line|
+        str.each_line(DELIMITER) {|line|
           next if /^!/ =~ line
           galist << GeneAssociation.new(line)
         }
@@ -411,71 +411,3 @@ end # module Bio
 
 
 
-if __FILE__ == $0
-
-  require 'net/http'
-
-  def wget(url)
-    if /http:\/\/(.+?)\// =~ url
-      host = $1
-      path = url[(url.index(host) + host.size)..url.size]
-    else
-      raise ArgumentError, "Invalid URL\n#{url}"
-    end
-
-    result = Net::HTTP.new(host).get(path).body
-  end
-
-
-
-  go_c_url = 'http://www.geneontology.org/ontology/component.ontology'
-  ga_url = 'http://www.geneontology.org/gene-associations/gene_association.sgd.gz'
-  e2g_url = 'http://www.geneontology.org/external2go/spkw2go'
-
-
-
-  puts "\n #==> Bio::GO::Ontology"
-  p go_c_url
-  component_ontology = wget(go_c_url)
-  comp = Bio::GO::Ontology.new(component_ontology)
-
-  [['0003673', '0005632'],
-    ['0003673', '0005619'],
-    ['0003673', '0004649']].each {|pair|
-    puts
-    p pair
-    p [:pair, pair.map {|i| [comp.id2term[i], comp.goid2term(i)] }]
-    puts "\n #==> comp.bfs_shortest_path(pair[0], pair[1])"
-    p comp.bfs_shortest_path(pair[0], pair[1])
-  }
-
-
-  puts "\n #==> Bio::GO::External2go"
-  p e2g_url
-  spkw2go = Bio::GO::External2go.new(wget(e2g_url))
-
-  puts "\n #==> spkw2go.db"
-  p spkw2go.db
-
-  puts "\n #==> spkw2go[1]"
-  p spkw2go[1]
-
-
-
-  require 'zlib'
-  puts "\n #==> Bio::GO::GeenAssociation"
-  p ga_url
-  ga = Zlib::Inflate.inflate(wget(ga_url))
-  ga = Bio::GO::GeneAssociation.parser(ga)
-
-  puts "\n #==> ga.size"
-  p ga.size
-
-  puts "\n #==> ga[100]"
-  p ga[100]
-
-
-
-
-  
-end

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

@@ -0,0 +1,112 @@
+#
+# = bio/db/kegg/common.rb - Common methods for KEGG database classes
+#
+# Copyright::  Copyright (C) 2003-2007 Toshiaki Katayama <k@bioruby.org>
+# Copyright::  Copyright (C) 2003 Masumi Itoh <m@bioruby.org>
+# Copyright::  Copyright (C) 2009 Kozo Nishida <kozo-ni@is.naist.jp>
+# License::    The Ruby License
+#
+#
+#
+# == Description
+#
+# Note that the modules in this file are intended to be Bio::KEGG::* 
+# internal use only.
+#
+# This file contains modules that implement methods commonly used from
+# KEGG database parser classes.
+#
+
+module Bio
+class KEGG
+
+  # Namespace for methods commonly used in the Bio::KEGG::* classes.
+  module Common
+
+    # The module providing dblinks_as_hash methods.
+    #
+    # Bio::KEGG::* internal use only.
+    module DblinksAsHash
+
+      # Returns a Hash of the DB name and an Array of entry IDs in
+      # DBLINKS field.
+      def dblinks_as_hash
+        unless defined? @dblinks_as_hash
+          hash = {}
+          dblinks_as_strings.each do |line|
+            db, ids = line.split(/\:\s*/, 2)
+            list = ids.split(/\s+/)
+            hash[db] = list
+          end
+          @dblinks_as_hash = hash
+        end
+        @dblinks_as_hash
+      end
+    end #module DblinksAsHash
+
+    # The module providing pathways_as_hash method.
+    #
+    # Bio::KEGG::* internal use only.
+    module PathwaysAsHash
+
+      # Returns a Hash of the pathway ID and name in PATHWAY field.
+      def pathways_as_hash
+        unless defined? @pathways_as_hash then
+          hash = {}
+          pathways_as_strings.each do |line|
+            sign, entry_id, name = line.split(/\s+/, 3)
+            hash[entry_id] = name
+          end
+          @pathways_as_hash = hash
+        end
+        @pathways_as_hash
+      end
+    end #module PathwaysAsHash
+
+    # This module provides orthologs_as_hash method.
+    #
+    # Bio::KEGG::* internal use only.
+    module OrthologsAsHash
+
+      # Returns a Hash of the orthology ID and definition in ORTHOLOGY field.
+      def orthologs_as_hash
+        unless defined? @orthologs_as_hash
+          kos = {}
+          orthologs_as_strings.each do |ko|
+            entry = ko.scan(/K[0-9]{5}/)[0]
+            sign, entry_id, definition = ko.split(/\s+/, 3)
+            kos[entry_id] = definition
+          end
+          @orthologs_as_hash = kos
+        end
+        @orthologs_as_hash
+      end
+    end #module OrthologsAsHash
+
+    # This module provides genes_as_hash method.
+    #
+    # Bio::KEGG::* internal use only.
+    module GenesAsHash
+
+      # Returns a Hash of the organism ID and an Array of entry IDs in
+      # GENES field.
+      def genes_as_hash
+        unless defined? @genes_as_hash
+          hash = {}
+          genes_as_strings.each do |line|
+            name, *list = line.split(/\s+/)
+            org = name.downcase.sub(/:/, '')
+            genes = list.map {|x| x.sub(/\(.*\)/, '')}
+            #names = list.map {|x| x.scan(/.*\((.*)\)/)}
+            hash[org] = genes
+          end
+          @genes_as_hash = hash
+        end
+        @genes_as_hash
+      end
+    end #module GenesAsHash
+
+  end #module Common
+end #class KEGG
+end #module Bio
+