Factory method: a factory method (or a factory function) is a function that creates an object. You don't necessarily know the exact name of the class of this object, but you know its interface.

Abstract factory: an abstract factory is an object maker, where, instead of specifying a class name, you specify the kind of object you want. It is very similar to an abstract method: just, instead of being a method, it is a class. For example, the FastaLoader is a factory of sequences. Given a filehandle, it returns a list of sequence objects of the proper class:

seq_factory = FastaLoader()
fh = open(my_fasta_file)
my_seqs = seq_factory.load(fh)
fh.close()
		    

Exercise 19.5. Point factory

Let's define a class that can create points for us. We could ask to such a factory to create new points by just providing the coordinates. This class could help us maintain a set of unique points by checking that a point of the sme coordinates does not already exist. factory = PointFactory() p1 = factory.create(3,4) p2 = factory.create(4,5) p3 = factory.create(4,5) p = factory.search(3,4) p.show() factory.delete(4,5) Solution 19.1

For instance, say that you want to create an agent to run analysis programs, you can ask a factory to do it for you:

clustalw = AnalysisFactory.program('clustalw')
result = clustalw.run(seqfile = 'myseqs')
print result.alig
		

Singleton: ensures that you cannot create more than one instance. A class attribute could be used to check the number of instanciations:

class Singleton:

    _nb = 0
    
    def __init__(self):
        if Singleton._nb > 0:
            raise Exception, "not more than one instance of " + str(self.__class__)
        Singleton._nb = 1

print "creating a 1st instance"
s1 = Singleton()

print "creating a 2nd instance"
s2 = Singleton()

Exception: not more than one instance of __main__.Singleton

		

For example, if you can define a class to contain operations and data for genetic code: you need only one instance of this class to perform the task. Actually, this pattern would not be implemented with a class in Python, but rather with a module, at least if you can define it statically (a dynamic singleton could not be a module, for a module has to be a file):

>>> import genetic_code
>>> genetic_code.aa('TTT')
F
		

Prototype: this pattern also lets you create a new object without knowing its class, but here, the new target object is created with the same state as the source object:

another_seq = seq.copy()
		

Builder: you sometimes need to create a complex object composed of several parts. This is the role of the builder.

Decorator, proxy, adapter: these patterns all enable to combine two (or more) components, as shown in Figure 19.7. There is one component, A, "in front" of another one, B. A is the visible object a client will see. The role of A is either to extend or restrict B, or help in using B. So, this pattern is similar to subclassing, except that, where a sub-class inherits a method from a base class, the decorator delegates to its decoratee when it does not have the required method. The advantage is flexibility (see Section 19.4.2): you can combine several of these components in any order at run time without having to create a big and complex hierarchy of subclasses.

Figure 19.7. Delegation

Generally, the Python code of the A class looks like:

class A:
        def __init__(self, b):
            """storing of the decoratee b (b is an instance of class B)"""
            self.b = b

        def __getattr__(self, name):
            """
               methods/attributes A does not know about are delegated
               to b 
            """
            return getattr(self.b, name)

class B:

    def f(self):
       return "result of f"

	      

>>> b = B()
>>> a = A(b)
>>> print a.f()
'result of f'
	      

Collection: this is a general pattern on how to collect items. You may need your own collection classes in numerous cases where you have several items to manage as a set, either ordered (list-like) or not ordered but accessible through keys (dictionary-like). Generally, you will need accessors to access the items, in various way:

You will also have a set of modificators, defined with your own specific rules:

# loading
fh = open(fastafile)
seqdb = DnaDB(fh)
fh.close()
# searching
l = seqdb.search('cctac')
for seq in l:
    print l
# modifying:
seqdb['new_seq'] = 'ccaggaggccctggcctctcactgaacccggccactcctctttggc'
print seqdb['new_seq']
# output the whole db:
print seqdb
# saving:
fh = open(fastafile, 'w')
seqdb.save(fh)
fh.close()
		

class SequenceDB:

    def __init__(self, fh=None):
        self._db = {}
        if fh is not None:
            self.load(fh)

    def load(self, fh):
        seq = ""
        line = fh.readline()
        while line:
            if line[0] == '>':
                if seq != '':
                    self[name] = seq
                name = line[1:-1]
            else:
                seq += line
            line = fh.readline()

        if seq != '':
            self[name] = seq
 
    def save(self, fh):
        for k in self._db.keys():
            seq = self._db[k]
            fh.write(str(seq))

    def __str__(self):
        result = ""
        for seq in self._db.values():
            result += str(seq) + "\n"
        return result[:-1]

    def search (self, keywd) :
        return [seq for seq in self._db.values() if keywd in seq.name or keywd in seq.seq]

    def __getattr__(self, attr):
        return getattr(self._db, attr)


class DnaDB(SequenceDB):

    def __setitem__(self, name, seq):
        if self._db.has_key(name):
            raise KeyError, name + ": this sequence already exists"
        self._db[name] = DNA(name=name, seq=seq)

class ProteinDB(SequenceDB):

    def __setitem__(self, name, seq):
        if self._db.has_key(name):
            raise KeyError, name + ": this sequence already exists"
        self._db[name] = Protein(name=name, seq=seq)
		

Composite: this pattern is often used to handle complex composite recursive structures. Example 19.9 shows a set of classes for a tree structure, illustrated in Figure 19.8. The main idea of the composite design pattern is to provide an uniform interface to instances from different classes in the same hierarchy, where instances are all components of the same composite complex object. In Example 19.9, you have two types of nodes: Node and Leaf, but you want a similar interface for them, that is at least defined by a common base class, AbstractNode, with two operations: print subtree. These operations should be callable on any node instance, without knowing its actual sub-class.

>>> t1 = Leaf( 'A', 0.71399)
>>> t2 = Node (Leaf('B', -0.00804), 
               Leaf('C', 0.07470))
>>> t3 = Node ( Leaf ( 'A', 0.71399),
                Node ( Node ( Leaf('B', -0.00804), 
                              Leaf('C', 0.07470), 
                              0.15685),
                       Leaf ('D', -0.04732),
                       0.0666),
              ) 

>>> print t3
(A: 0.71399, ((B: -0.00804, C: 0.0747): 0.15685, D: -0.04732): 0.0666)
>>> t4 = t3.right.subtree()
>>> print t4
((B: -0.00804, C: 0.0747): 0.15685, D: -0.04732)
>>> t5 = t3.left.subtree()
>>> print t5
'A': 0.71399
		

Figure 19.8. A composite tree

Example 19.9. A composite tree

		                                                                        
class AbstractNode:

    def __str__(self):
        pass

    def subtree(self):
        pass
                                                                          
class Node(AbstractNode):
    def __init__(self, left=None, right=None, length=None):
        self.left=left
        self.right=right
        self.length=length

    def __str__(self):
	if self.length:
	    return "(" + self.left.__str__() + ", " + self.right.__str__() + ")" + ": " + str(self.length) 
	else:
	    return "(" + self.left.__str__() + ", " + self.right.__str__() + ")"
    
    def subtree(self):                                                    
        return Node(self.left, self.right)

class Leaf(AbstractNode):
    def __init__(self, name, length=None):
        self.name = name
        self.length=length
        self.left = None
        self.right = None

    def __str__(self):
        return self.name + ": " + str(self.length)

    def subtree(self):
        return Leaf(self.name, self.length)


if __name__ == "__main__":
    t1 = Leaf( 'A', 0.71399)
    print t1
    t2 = Node (Leaf('B', -0.00804), 
	       Leaf('C', 0.07470))
    print t2
    t3 = Node ( Leaf ( 'A', 0.71399),
		Node ( Node ( Leaf('B', -0.00804), 
			      Leaf('C', 0.07470), 
			      0.15685),
		       Leaf ('D', -0.04732),
		       0.0666),
		)

    print t3





		    

	Abstract class AbstractNode, base class for both Node and Leaf
	Internal nodes are instances of Node class.
	Leafs are instances of Leaf class.

Template: this pattern consists in separating the invariant part of an algorithm from the variant part. In a sorting procedure, you can generally separate the function which compares items from the main body of the algorithm. The template method, in this case, is the sort() method, whereas the compare() can be defined by each subclass depending on its implementation or data types.

The following function defines a typical search, which objective is to verify a property on the whole sequence. So it stops whenever a property is not verified on a single element of the sequence. The structure of this search is a kind of template.

def check_whole_seq(seq, check_fn):
    for c in seq:
        if not check_fn(c):
            return False
    return True
		

A related template would be to search in the sequence whether a propoerty is verified at least once:

def check_has_seq(seq, check_fn):
    for c in seq:
        if check_fn(c):
            return True
    return False
		

Strategy: the boolean function in the examples above can be called a strategy, because it provides the logic which decides for the result of the search. Examples of such function are listed below:

def is_dna(c):
    return c in 'atcgATCG'

def is_gap(c):
    return c in '-.'

def is_amino_acid(c):
    AA = upper(c) 
    if AA < 'A' or AA > 'Z':
        return False
    if AA in 'JOU':
        return False
    return True

def is_upper(c):
    return c == upper(c)

def is_letter(c):
    return c in ascii_letters
		  

check_whole_seq('tgtcgt', is_dna)
check_whole_seq('MAI', is_amino_acid)
check_has_seq('tg-tcgt', is_gap)
		  

In the following example, the f_test method is a strategy:

class MotifDB:

    def __init__(self, fh=None, db=None):
        self._db = []
        if fh is not None:
            self._load_fh(fh)
        elif db is not None:
            self._load_db(db)

    def filter(self, f_test) :
        return self.__class__(db=[motif for motif in self._db if f_test(motif)])

    new_db = db.filter(lambda(motif): 'kinase' in motif.get_desc())

Iterator: an iterator is an object that let you browse a sequence of items from the beginning to the end. Generally, it provides:

Usually, one distinguishes internal versus external iterators. An external iterator is an iterator which enables to do a for or a while loop on a range of values that are returned by the iterator:

for e in l.elements():
     f(e)
		  

i = l.iterator()
e = i.next()
while e:
   f(e)
   e = i.next()
		  

l.iterate(f)
		  

In the Biopython package, files and databases are generally available through an iterator.

handle = open(...)                                                        
iter = Bio.Fasta.Iterator(handle)                                         
seq = iter.next()                                                         
while seq:
  print seq.name
  print seq.seq                                                           
  seq = iter.next()
handle.close()
		  

	Starting the iterator.
	Getting the next element.
	Testing for the end of the iteration.
	Getting the next element.

Visitor: this pattern is useful to specify a function that will be applied on each item of a collection. The Python map function provides a way to use visitors, such as the f function, which visits each item of the l list in turn:

>>> def f(x):
	return x + 1
>>> l=[0,1,2]
>>> map(f,l)
[1, 2, 3]
	      

def walk_leaves(tree, visitor):
    if type(tree) is types.ListType:
        for child in tree:
            walk_leaves(child, visitor)
    else:
        visitor(tree)

def output(e):
    print e

        
tree = [[[['human', 'chimpanzee'], 'gorilla'], 'orang-utan'], 'gibbon']
walk_leaves(tree, output)
		

def binary_traverse(tree, make):
    if type(tree) is types.ListType:
        left = binary_traverse(tree[0], make)
        right = binary_traverse(tree[1], make)
        print left, right
        return make(left, right)
    else:
        return make(tree)

def build_list(*l):
    if len(l) == 1:
        return [l[0]]
    _l = []
    for e in l:
        _l = _l + e
    return _l

t1 = binary_traverse(tree, build_list)
['human'] ['chimpanzee']
['human', 'chimpanzee'] ['gorilla']
['human', 'chimpanzee', 'gorilla'] ['orang-utan']
['human', 'chimpanzee', 'gorilla', 'orang-utan'] ['gibbon']

def build_string(*l):
    if len(l) == 1:
        return str(l[0])
    _s = "("
    for e in l:
        _s = _s + str(e) + ","
    return _s[:-1] + ")"

t2 = binary_traverse(tree, build_string)
human chimpanzee
(human,chimpanzee) gorilla
((human,chimpanzee),gorilla) orang-utan
(((human,chimpanzee),gorilla),orang-utan) gibbon
		

Observer The observer pattern provides a framework to maintain a consistent distributed state between loosely coupled components. One agent, the observer, is in charge of maintaining a list of subscribers, e.g components that have subscribed to be informed about changes in a given state. Whenever a change occurs in a state, the observer has to inform each subscriber about it.

A well-known example is the Model-View-Controller [Krasner88] framework. The view components, the ones who actually display data, subscribe to "edit events" in order to be able to refresh and redisplay them whenever a change occurs.