seq – Sequences and Alignments¶

Attaching Structures to Sequences¶

As OpenStructure is a computational structural biology framework, it is not surprising that the sequence classes have been designed to work together with structural data. Each sequence can have an attached EntityView allowing for fast mapping between residues in the entity view and position in the sequence.

A acefghiklmnpqrstuvwy
B     ghiklm
C     123-45

Loading and Saving Sequences and Alignments¶

The io module supports input and output of common sequence formats. Single sequences can be loaded from disk with io.LoadSequence(), alignments are loaded with io.LoadAlignment() and lists of sequences are loaded with io.LoadSequenceList(). In addition to the file based input methods, sequences can also be loaded from a string:

seq_string='''>sequence
abcdefghiklmnop'''
s=io.SequenceFromString(seq_string, 'fasta')
print s.name, s # will print "sequence abcdefghiklmnop"

Note that, in that case specifying the format is mandatory.

The SequenceHandle¶

CreateSequence(name, sequence)¶

Create a new SequenceHandle with the given name and sequence.

Parameters:	name (str) – name of the sequence sequence (str) – String of characters representing the sequence. Only ‘word’ characters (no digits), ‘?’, ‘-‘ and ‘.’ are allowed. In an upcoming release, ‘?’ and ‘.’ will also be forbidden so its best to translate those to ‘X’ or ‘-‘.
Raises InvalidSequence:
	When the sequence string contains forbidden characters. In the future, ‘?’ and ‘.’ will also raise this exception.

class SequenceHandle¶

Represents a sequence. New instances are created with CreateSequence().

GetPos(residue_index)¶

Get position of residue with index in sequence. This is best illustrated in the following example:

s=seq.CreateSequence("A", "abc---def")
print s.GetPos(1) # prints 1
print s.GetPos(3) # prints 6

The reverse mapping, that is from position in the sequence to residue index can be achieved with GetResidueIndex().

GetResidueIndex(pos)¶

Get residue index of character at given position. This method is the inverse of GetPos(). If the sequence contains a gap at that position, an Error is raised.

s=seq.CreateSequence("A", "abc--def")
print s.GetResidueIndex(1) # prints 1
print s.GetResidueIndex(6) # prints 4
# the following line raises an exception of type
# Error with the message "requested position contains
# a gap"
print s.GetResidueIndex(3)

GetResidue(pos)¶

As, GetResidueIndex(), but directly returns the residue view. If no view is attached, or if the position is a gap, an invalid residue view is returned.

Return type:	ResidueView

GetLastNonGap()¶

Get position of last non-gap character in sequence. In case of an empty sequence, or, a sequence only consisting of hyphens, -1 is returned

GetFirstNonGap()¶

Get position of first non-gap character in sequence. In case of an empty sequence, or, a sequence only consisting of hyphens, -1 is returned.

AttachView(view)¶

AttachView(view[, chain_name])

Attach an EntityView to sequence. The first signature requires that the view contains one chain. If not, an IntegrityError is raised. The second signature will select the chain with the given name. If no such chain exists, an IntegrityError is raised.

HasAttachedView()¶

Returns True when the sequence has a view attached, False if not.

GetAttachedView()¶

Returns the attached EntityView, or an invalid EntityView if no view has been attached. Also available as the property attached_view.

GetName()¶

Returns the name of the sequence. Also available as the property name

SetOffset()¶

Set the sequence offset. By default, the offset is 0. Also available as the property offset.

GetOffset()¶

Returns the sequence offset. Also available as offset.

GetGaplessString()¶

Returns a string version of this sequence with all hyphens removed. Also available as the property gapless_string.

SetName()¶

Set name of the sequence. Also available as the property name.

gapless_string¶

Shorthand for GetGaplessString()

name¶

Shorthand for GetName()/SetName()

attached_view¶

Shorthand for GetAttachedView().

offset¶

Shorthand for GetOffset()/SetOffset()

__len__()¶

Returns the length of the sequence (including insertions and deletions)

__str__()¶

Returns the sequence as a string.

Match(s1, s2)¶

Parameters:	s1 (SequenceHandle, or str) – The first sequence s2 (SequenceHandle, or str) – The second sequence

Check whether the two sequences s1 and s2 match. This function performs are case-insensitive comparison of the two sequences. The character ‘X’ is interpreted as a wildcard character that always matches the other sequence.

The SequenceList¶

class SequenceList¶

Represents a list of sequences. The class provides a row-based interface. New instances are created with CreateSequenceList().

The AlignmentHandle¶

The AlignmentHandle represents a list of aligned sequences. In constrast to SequenceList, an alignment requires all sequences to be of the same length. New instances of alignments are created with CreateAlignment() and AlignmentFromSequenceList().

Typically sequence alignments are used column-based, i.e by looking at an aligned columns in the sequence alignment. To get a row-based (sequence) view on the sequence list, use GetSequenceList().

All functions that operate on an alignment will again produce a valid alignment. This mean that it is not possible to change the length of one sequence, without adjusting the other sequences, too.

The following example shows how to iterate over the columns and sequences of an alignment:

aln=io.LoadAlignment('aln.fasta')
# iterate over the columns
for col in aln:
  print col

# iterate over the sequences
for s in aln.sequences:
  print s

CreateAlignment()¶

Creates and returns a new AlignmentHandle with no sequences.

AlignmentFromSequenceList(sequences)¶

Create a new alignment from the given list of sequences

Parameters:	sequences (ConstSequenceList) – the list of sequences
Raises :	InvalidAlignment if the sequences do not have the same length.

class AlignmentHandle¶

Note

Several of these methods just forward calls to the sequence. For more detailed information, have a look at the SequenceHandle documentation.

GetSequence(index)¶

Returns the sequence at the given index, raising an IndexError when trying to access an inexistent sequence.

GetSequenceList()¶

Returns a list of all sequence of the alignment.

GetLength()¶

Returns the length of the alignment.

GetCount()¶

Returns the number of sequences in the alignment.

ToString(width=80)¶

Returns a formatted string version of the alignment. The sequences are split into smaller parts to fit into the number columns specified.

aln=seq.CreateAlignment()
aln.AddSequence(seq.CreateSequence("A", "abcdefghik"))
aln.AddSequence(seq.CreateSequence("B", "1234567890"))
# The following command will print the output given below
print aln.ToString(7)
# A abcde
# B 12345
#
# A fghik
# B 67890

FindSequence(name)¶

Find sequence with given name. If the alignment contains several sequences with the same name, the first sequence is returned.

SetSequenceName(seq_index, name)¶

Set the name of the sequence at index seq_index to name

SetSequenceOffset(seq_index, offset)¶

Set the sequence offset of sequence at index seq_index

Copy()¶

Create a deep copy of the alignment

GetPos(seq_index, res_index)¶

Get position of residue with index equal to res_index in sequence at index seq_index.

GetResidueIndex(seq_index, pos)¶

Get residue index of residue at position pos in sequence at index seq_index.

AttachView(seq_index, view)¶

AttachView(seq_index, view, chain_name)

Attach the given view to the sequence at index seq_index.

Cut(start, end)¶

Removes the columns in the half-closed interval start, end from the alignment.

aln=seq.CreateAlignment()
aln.AddSequence(seq.CreateSequence("A", "abcd---hik"))
aln.AddSequence(seq.CreateSequence("B", "1234567890"))
aln.Cut(4, 7)

print aln.ToString(80)
# will print
# A abcdhik
# B 1234890

Replace(new_region, start, end)¶

Replace the columns in the half-closed interval start, end with the columns in new_region.

Parameters:	new_region (AlignedRegion or AlignmentHandle) – The region to be inserted

ShiftRegion(start, end, amount, master=-1)¶

Shift columns in the half-closed interval start, end. If amount is a positive number, the columns are shifted to the right, if negative, the columns are shifted to the left.

If master is set to -1, all sequences in the region are affected, otherwise only the sequence at index equal to master is shifted.

GetMatchingBackboneViews(index1=0, index2=1)¶

Returns a tuple of entity views containing matching backbone atoms for the two sequences at index1 and index2, respectively. For each aligned column in the alignment, backbone atoms are added to the view if both aligned residues have them. It is guaranteed that the two views contain the same number of atoms and that the order of the atoms in the two views is the same.

The output of this function can be used to superpose two structures with SuperposeSVD().

Parameters:	index1 – The index of the first sequence index2 – The index of the second sequence.
Raises :	In case one of the two sequences doesn’t have an attached view, a RuntimeError is raised.

AddSequence(sequence)¶

Append a sequence to the alignment. The sequence must have the same length as sequences already present in the alignment.

Raises :	RuntimeError if the sequence length does not match
Parameters:	sequence (ConstSequenceHandle) – Sequence to be added

GetSequenceOffset(index)¶

SetSequenceOffset(index, offset)

Get/set the offset for sequence at index.

Parameters:	index (int) – The index of the sequence offset (int) – The new offset
Return type:	int

GetSequenceRole(index)¶

SetSequenceRole(index, role)¶

Get/Set the sequence role for sequence at index.

Parameters:	index (int) – The index of the sequence role (str) – The new role
Return type:	str

GetCoverage(index)¶

Get coverage of sequence at index to the first sequence.

Parameters:	index (int) – The index of the sequence
Returns:	Coverage as a number between 0 and 1.

RemoveSequence(index)¶

Remove sequence at index from the alignment.