Implementing chain of responsibility

koranthala koranthala at
Mon Mar 9 11:54:25 CET 2009

On Mar 9, 12:16 pm, Chris Rebert <c... at> wrote:
> On Sun, Mar 8, 2009 at 11:53 PM, koranthala <koranth... at> wrote:
> > Hi,
> >    I want to implement chain of responsibility pattern in Python (for
> > a Django project)
> >    The problem that I see is a rather odd one - how to link the
> > subclasses with the super class.
> Grabbing out my copy of Head First Design Patterns and looking up this
> pattern, it sounds like you're going about this the wrong way. From
> what I can grok, Chain-of-Responsibility looks like this:
> class SomeHandler(object)
>     def __init__(self, successor=None):
>         self.successor = successor
>     def theMethod(self, theRequest):
>         result = try_and_handle(theRequest)
>         if did_not_handle(theRequest) and self.successor is not None:
>             return successor.theMethod(theRequest)
>         else:
>             return result
> #imagine some other handler classes
> #setup:
> masterHandler = SomeHandler(OtherHandler(ThirdHandler()))
> #usage:
> result = masterHandler.theMethod(aRequest)
> So the *classes* don't ever know anything about each other; you pass a
> handler class an instance of its successor handler at
> construction-time. So there's no need for any registry or
> introspection at all. You determine the ordering at runtime when you
> construct the instances.
> Of course, this entire pattern is usually unnecessary in Python as you
> can usually write the same thing less verbosely and more
> straightforwardly as:
> def someHandler(theRequest):
>     result = try_and_handle(theRequest)
>     if did_not_handle(theRequest):
>         return False, None
>     else:
>         return True, result
> #imagine some other handler functions
> #setup:
> handlers = [someHandler, otherHandler, thirdHandler]
> #usage:
> for handler in handlers:
>     success, result = handler(theRequest)
>     if success: break
> Note the lack of classes and how the sequencing is now made explicit.
> Cheers,
> Chris
> --
> I have a blog:

    Thank you very much Chris for the extremely quick and helpful
    I agree that it is not perfect CoR as per the examples given. But,
I have done it very similar to the second example that you had given.
I needed classes because I am not doing just one thing - I have a lot
of pre-processing and post processing, so I had used classes. The
register methods etc are just a fancy way of creating the list as you
mentioned. I am using the registry because there are many procedures
wherein different methods of the classes in registry are being used.
    I am not sure whether I have understood your points completely. I
still cannot understand how to do the import so that the register
methods are hit.

More information about the Python-list mailing list