[BioPython] Sequence numbering. Moving on...

[Iddo Friedberg]

Hi,

Moving on the sequence object proposition, I propose the following:

1) A sequence will be a base class, with subclasses for nucleotide and
peptide sequences. The subclasses will be used.

2) A method which returns a sequence, will return a sequence object, not a
string.

3) I liked Andrew's compromise. I think the __call__ method should wrap
one of the others (either python, seq, perl, omg; I'm partial to the seq 
method myself), and that will be our
wrapper. If we wish to make things more flexible, the __call__ method may
accept as it's last argument the name of the method it wraps. See the
``Alternative __call__ method'', bottom.

4) I'm not very good at streamlining Python code. If anyone likes this and
has a proposition on how to make this faster, I'd like to know.


So:

>>> seq=sequence.DNASeq('ATGC')
>>> seq(1,3)
['A', 'T', 'G']

#(using the alternate __call__ method):
>>> seq(1,3,'python')   # using the alternate __call__ method
['T', 'G']

>>> seq(1,3).complement()
['T', 'A', 'C']



Iddo

PS: I use tab indentations. Set your editor to 3 space tabstops, and the
following should look fine

------------------------------ CUT HERE ----------------------------
from UserList import UserList

# Base class for sequences
class Seq(UserList):
	def __init__(self, inseq=''):
		self.data = []
		for i in inseq:
			self.append(i)
	def __call__(self, min=None, max=None):
	# The call method will be used with the seq attribute. This is the
	# wrapper
		if min == None:
			min = 1
		if max == None:
			max = len(self)
		retSeq = self.__class__((self.seq(min,max)))
		return retSeq

	def seq(self, min, max):
		# with a base of 1 and including the end
		# Negative slice notation not allowed
		assert max >= min and min >0
		return self[min-1:max]
	def omg(self, min, max):
		# with a base of 1 and excluding the end
		# Negative slice notation not allowed
		assert min>=1 and max>min
		return self[min-1:max-1]
	def perl(self, min, max):
		# with a base of 0 and including the end
		# Negative slice notation not allowed
		assert min>=1 and max>=min
		return self[min:max+1]
	def python(self, min, max):
		return self[min:max]

compTable = {'A':'T', 'T':'A', 'G':'C', 'C':'G'}
class DNASeq(Seq):
	# Example of a nucleotide sequence subclass, with a method
	def complement(self, min=None, max=None):
		retSeq = DNASeq()
		for i in self(min,max): # This calls the seq attribute in the
										# base class
			retSeq.append(compTable[i])
		return retSeq

chargeTable = {'E':-1., 'D':-1., 'K':1., 'R':1, 'H':0.5}
class PEPSeq(Seq):
	# Example of an amino-acid subclass, with a method
	def charge(self, min=None, max=None):
		c=0.
		for i in self(min,max): # This calls the seq attribute 
										# in the base class
			try:
				c = c + chargeTable[i]
			except KeyError:
				pass
		return c



--------------------------------------------------------
Alternative __call__ method:

	# The call method will be used with the any attribute. This is the
	# wrapper
	def __call__(self, min=None, max=None, attrib='seq'):
		if min == None:
			min = 1
		if max == None:
			max = len(self)
		retSeq = getattr(self,attrib)(min,max)
		return self.__class__(retSeq)