An observer pattern application.

[Paolino]

Lately I was needing to use multiple inheritance to split behaviour of a
class and modularize it.
But the problem raises when the need is to add operations to a method
already present in one of them from another.
I think the technical solution is the use of 'super'.
Then I tried to write a decorator for automatize the 'super' call,but I
failed.

Next solution is implementing the observer pattern on methods call.
I'm pretty sure there are bugs and ideas to be corrected in the next
code,any help and comment appreciated.

Regards Paolino

########################################################################################

''' A module collecting classes for known patterns

'''

import types

class Observer(dict):
''' A class defining some decorators for function/methods to
chain/link them when called .To do:implement pre event execution hooking'''

def __call__(self,observed,args,kwargs):
for reaction in self.get(observed,()):
reaction(*args,**kwargs)

def emit(self,method,observed=None):
''' A decorator for functions to signal their calling.Post hook
cablated'''
def wrapper(*args,**kwargs):
if observed:
if type(observed) is types.MethodType:
event=observed.im_func
else:
event=observed
else:
event=wrapper
result=method(*args,**kwargs)
self(wrapper,args,kwargs)
return result
return wrapper

def emitOther(self,observed):
''' A decorator facility to let the function/method emit another
event (not itself)'''
def wrapEmit(method):
return self.emit(method,observed)
return wrapEmit

def reactOn(self,*observeds):
''' a decorator to set the function/method as a reaction to
*observeds event.
Remember to use __ name mangling when working on methods to be
able to use
same reaction name on multiple class inheritances'''
def reaction(method):
for observed in observeds:
if type(observed) is types.MethodType:
observed=observed.im_func
self.setdefault(observed,set()).add(method)
return method
return reaction


if __name__=='__main__':
observer=Observer()
class base(object):
@observer.emit
def method(self,*args,**kwargs):
print '%s.method'%str(self),args,kwargs

class extensionA(object):
@observer.reactOn(base.method)
def __methodReaction(self,*args,**kwargs):
print 'A,%s.methodReaction'%str(self),args,kwargs

class extensionB(object):
@observer.reactOn(base.method)
def __methodReaction(self,*args,**kwargs):
print 'B,%s.methodReaction'%str(self),args,kwargs

class applicable(base,extensionA,extensionB):
@observer.reactOn(base.method)
def __methodReaction(self,*args,**kwargs):
print 'applicable,%s.methodReaction'%str(self),args,kwargs

pass

applicable().method('cucu')


___________________________________
Yahoo! Messenger: chiamate gratuite in tutto il mondo
http://it.beta.messenger.yahoo.com