Bio::Sequence objects represent annotated sequences in bioruby. A Bio::Sequence object is a wrapper around the actual sequence, represented as either a Bio::Sequence::NA or a Bio::Sequence::AA object. For most users, this encapsulation will be completely transparent. Bio::Sequence responds to all methods defined for Bio::Sequence::NA/AA objects using the same arguments and returning the same values (even though these methods are not documented specifically for Bio::Sequence).
# Create a nucleic or amino acid sequence
dna = Bio::Sequence.auto('atgcatgcATGCATGCAAAA')
rna = Bio::Sequence.auto('augcaugcaugcaugcaaaa')
aa = Bio::Sequence.auto('ACDEFGHIKLMNPQRSTVWYU')
# Print it out
puts dna.to_s
puts aa.to_s
# Get a subsequence, bioinformatics style (first nucleotide is '1')
puts dna.subseq(2,6)
# Get a subsequence, informatics style (first nucleotide is '0')
puts dna[2,6]
# Print in FASTA format
puts dna.output(:fasta)
# Print all codons
dna.window_search(3,3) do |codon|
puts codon
end
# Splice or otherwise mangle your sequence
puts dna.splicing("complement(join(1..5,16..20))")
puts rna.splicing("complement(join(1..5,16..20))")
# Convert a sequence containing ambiguity codes into a
# regular expression you can use for subsequent searching
puts aa.to_re
# These should speak for themselves
puts dna.complement
puts dna.composition
puts dna.molecular_weight
puts dna.translate
puts dna.gc_percent
| classification | -> | taxonomy |
| classification | [RW] | Organism classification, taxonomic classification of the source organism. (Array of String) |
| comments | [RW] | Comments (String or an Array of String) |
| data_class | [RW] | Data Class defined by EMBL (String) See www.ebi.ac.uk/embl/Documentation/User_manual/usrman.html#3_1 |
| date_created | [RW] | Created date of the sequence entry (Date, DateTime, Time, or String) |
| date_modified | [RW] | Last modified date of the sequence entry (Date, DateTime, Time, or String) |
| dblinks | [RW] | Links to other database entries. (An Array of Bio::Sequence::DBLink objects) |
| definition | [RW] | A String with a description of the sequence (String) |
| division | [RW] | Taxonomic Division defined by EMBL/GenBank/DDBJ (String) See www.ebi.ac.uk/embl/Documentation/User_manual/usrman.html#3_2 |
| entry_id | [RW] | The sequence identifier (String). For example, for a sequence of Genbank origin, this is the locus name. For a sequence of EMBL origin, this is the primary accession number. |
| entry_version | [RW] | Version of the entry (String or Integer). Unlike sequence_version, entry_version is a database maintainer‘s internal version number. The version number will be changed when the database maintainer modifies the entry. The same enrty in EMBL, GenBank, and DDBJ may have different entry_version. |
| features | [RW] | Features (An Array of Bio::Feature objects) |
| id_namespace | [RW] | Namespace of the sequence IDs described in entry_id, primary_accession, and secondary_accessions methods (String). For example, ‘EMBL’, ‘GenBank’, ‘DDBJ’, ‘RefSeq’. |
| keywords | [RW] | Keywords (An Array of String) |
| molecule_type | [RW] | molecular type (String). "DNA" or "RNA" for nucleotide sequence. |
| moltype | [RW] | Bio::Sequence::NA/AA |
| organelle | [RW] | (not well supported) Organelle information (String). |
| other_seqids | [RW] | Sequence identifiers which are not described in entry_id, primary_accession,and secondary_accessions methods (Array of Bio::Sequence::DBLink objects). For example, NCBI GI number can be stored. Note that only identifiers of the entry itself should be stored. For database cross references, dblinks should be used. |
| primary_accession | [RW] | Primary accession number (String) |
| references | [RW] | References (An Array of Bio::Reference objects) |
| release_created | [RW] | Release information when created (String) |
| release_modified | [RW] | Release information when last-modified (String) |
| secondary_accessions | [RW] | Secondary accession numbers (Array of String) |
| seq | [RW] | The sequence object, usually Bio::Sequence::NA/AA, but could be a simple String |
| sequence_version | [RW] | Version number of the sequence (String or Integer). Unlike entry_version, sequence_version will be changed when the submitter of the sequence updates the entry. Normally, the same entry taken from different databases (EMBL, GenBank, and DDBJ) may have the same sequence_version. |
| species | [RW] | Organism species (String). For example, "Escherichia coli". |
| strandedness | [RW] | Strandedness (String). "single" (single-stranded), "double" (double-stranded), "mixed" (mixed-stranded), or nil. |
| topology | [RW] | Topology (String). "circular", "linear", or nil. |
Normally, users should not call this method directly. Use Bio::*to_biosequence (e.g. Bio::GenBank#to_biosequence).
Creates a new Bio::Sequence object from database data with an adapter module.
# File lib/bio/sequence.rb, line 442
442: def self.adapter(source_data, adapter_module)
443: biosequence = self.new(nil)
444: biosequence.instance_eval {
445: remove_instance_variable(:@seq)
446: @source_data = source_data
447: }
448: biosequence.extend(adapter_module)
449: biosequence
450: end
Given a sequence String, guess its type, Amino Acid or Nucleic Acid, and return a new Bio::Sequence object wrapping a sequence of the guessed type (either Bio::Sequence::AA or Bio::Sequence::NA)
s = Bio::Sequence.auto('atgc')
puts s.seq.class #=> Bio::Sequence::NA
Arguments:
| Returns: | Bio::Sequence object |
# File lib/bio/sequence.rb, line 262
262: def self.auto(str)
263: seq = self.new(str)
264: seq.auto
265: return seq
266: end
Guess the class of a given sequence. Returns the class (Bio::Sequence::AA or Bio::Sequence::NA) guessed. In general, used by developers only, but if you know what you are doing, feel free.
puts .guess('atgc') #=> Bio::Sequence::NA
There are three optional parameters: `threshold`, `length`, and `index`.
The `threshold` value (defaults to 0.9) is the frequency of nucleic acid bases [AGCTUagctu] required in the sequence for this method to produce a Bio::Sequence::NA "guess". In the default case, if less than 90% of the bases (after excluding [Nn]) are in the set [AGCTUagctu], then the guess is Bio::Sequence::AA.
puts Bio::Sequence.guess('atgcatgcqq') #=> Bio::Sequence::AA
puts Bio::Sequence.guess('atgcatgcqq', 0.8) #=> Bio::Sequence::AA
puts Bio::Sequence.guess('atgcatgcqq', 0.7) #=> Bio::Sequence::NA
The `length` value is how much of the total sequence to use in the guess (default 10000). If your sequence is very long, you may want to use a smaller amount to reduce the computational burden.
# limit the guess to the first 1000 positions
puts Bio::Sequence.guess('A VERY LONG SEQUENCE', 0.9, 1000)
The `index` value is where to start the guess. Perhaps you know there are a lot of gaps at the start…
puts Bio::Sequence.guess('-----atgcc') #=> Bio::Sequence::AA
puts Bio::Sequence.guess('-----atgcc',0.9,10000,5) #=> Bio::Sequence::NA
Arguments:
| Returns: | Bio::Sequence::NA/AA |
# File lib/bio/sequence.rb, line 360
360: def self.guess(str, *args)
361: self.new(str).guess(*args)
362: end
Create a new Bio::Sequence object from a formatted string (GenBank, EMBL, fasta format, etc.)
s = Bio::Sequence.input(str)
Arguments:
| Returns: | Bio::Sequence object |
# File lib/bio/sequence.rb, line 415
415: def self.input(str, format = nil)
416: if format then
417: klass = format
418: else
419: klass = Bio::FlatFile::AutoDetect.default.autodetect(str)
420: end
421: obj = klass.new(str)
422: obj.to_biosequence
423: end
Create a new Bio::Sequence object
s = Bio::Sequence.new('atgc')
puts s #=> 'atgc'
Note that this method does not intialize the contained sequence as any kind of bioruby object, only as a simple string
puts s.seq.class #=> String
See Bio::Sequence#na, Bio::Sequence#aa, and Bio::Sequence#auto for methods to transform the basic String of a just created Bio::Sequence object to a proper bioruby object
Arguments:
| Returns: | Bio::Sequence object |
# File lib/bio/sequence.rb, line 94
94: def initialize(str)
95: @seq = str
96: end
alias of Bio::Sequence.input
# File lib/bio/sequence.rb, line 426
426: def self.read(str, format = nil)
427: input(str, format)
428: end
Transform the sequence wrapped in the current Bio::Sequence object into a Bio::Sequence::NA object. This method will change the current object. This method does not validate your choice, so be careful!
s = Bio::Sequence.new('atgc')
puts s.seq.class #=> String
s.aa
puts s.seq.class #=> Bio::Sequence::AA !!!
However, if you know your sequence type, this method may be constructively used after initialization,
s = Bio::Sequence.new('RRLE')
s.aa
| Returns: | Bio::Sequence::AA |
# File lib/bio/sequence.rb, line 401
401: def aa
402: @seq = AA.new(seq)
403: @moltype = AA
404: end
Guess the type of sequence, Amino Acid or Nucleic Acid, and create a new sequence object (Bio::Sequence::AA or Bio::Sequence::NA) on the basis of this guess. This method will change the current Bio::Sequence object.
s = Bio::Sequence.new('atgc')
puts s.seq.class #=> String
s.auto
puts s.seq.class #=> Bio::Sequence::NA
| Returns: | Bio::Sequence::NA/AA object |
# File lib/bio/sequence.rb, line 243
243: def auto
244: @moltype = guess
245: if @moltype == NA
246: @seq = NA.new(seq)
247: else
248: @seq = AA.new(seq)
249: end
250: end
Guess the class of the current sequence. Returns the class (Bio::Sequence::AA or Bio::Sequence::NA) guessed. In general, used by developers only, but if you know what you are doing, feel free.
s = Bio::Sequence.new('atgc')
puts s.guess #=> Bio::Sequence::NA
There are three parameters: `threshold`, `length`, and `index`.
The `threshold` value (defaults to 0.9) is the frequency of nucleic acid bases [AGCTUagctu] required in the sequence for this method to produce a Bio::Sequence::NA "guess". In the default case, if less than 90% of the bases (after excluding [Nn]) are in the set [AGCTUagctu], then the guess is Bio::Sequence::AA.
s = Bio::Sequence.new('atgcatgcqq')
puts s.guess #=> Bio::Sequence::AA
puts s.guess(0.8) #=> Bio::Sequence::AA
puts s.guess(0.7) #=> Bio::Sequence::NA
The `length` value is how much of the total sequence to use in the guess (default 10000). If your sequence is very long, you may want to use a smaller amount to reduce the computational burden.
s = Bio::Sequence.new(A VERY LONG SEQUENCE) puts s.guess(0.9, 1000) # limit the guess to the first 1000 positions
The `index` value is where to start the guess. Perhaps you know there are a lot of gaps at the start…
s = Bio::Sequence.new('-----atgcc')
puts s.guess #=> Bio::Sequence::AA
puts s.guess(0.9,10000,5) #=> Bio::Sequence::NA
Arguments:
| Returns: | Bio::Sequence::NA/AA |
# File lib/bio/sequence.rb, line 307
307: def guess(threshold = 0.9, length = 10000, index = 0)
308: str = seq.to_s[index,length].to_s.extend Bio::Sequence::Common
309: cmp = str.composition
310:
311: bases = cmp['A'] + cmp['T'] + cmp['G'] + cmp['C'] + cmp['U'] +
312: cmp['a'] + cmp['t'] + cmp['g'] + cmp['c'] + cmp['u']
313:
314: total = str.length - cmp['N'] - cmp['n']
315:
316: if bases.to_f / total > threshold
317: return NA
318: else
319: return AA
320: end
321: end
Transform the sequence wrapped in the current Bio::Sequence object into a Bio::Sequence::NA object. This method will change the current object. This method does not validate your choice, so be careful!
s = Bio::Sequence.new('RRLE')
puts s.seq.class #=> String
s.na
puts s.seq.class #=> Bio::Sequence::NA !!!
However, if you know your sequence type, this method may be constructively used after initialization,
s = Bio::Sequence.new('atgc')
s.na
| Returns: | Bio::Sequence::NA |
# File lib/bio/sequence.rb, line 380
380: def na
381: @seq = NA.new(seq)
382: @moltype = NA
383: end
Return sequence as String. The original sequence is unchanged.
seq = Bio::Sequence.new('atgc')
puts s.to_s #=> 'atgc'
puts s.to_s.class #=> String
puts s #=> 'atgc'
puts s.class #=> Bio::Sequence
| Returns: | String object |
# File lib/bio/sequence/compat.rb, line 32
32: def to_s
33: String.new(self.seq)
34: end