Title: Memento Closure
Submitter: Zoran Isailovski (other recipes)
Last Updated: 2005/05/11
Version no: 1.2
Category: OOP

Description:

The memento pattern is great for transaction-like processing. Having a handy implementation around might not be the worst thing.

Source: Text Source

import copy

def Memento(obj, deep=False):
   state = (copy.copy, copy.deepcopy)[bool(deep)](obj.__dict__)
   def Restore():
      obj.__dict__.clear()
      obj.__dict__.update(state)
   return Restore

class Transaction:
   """A transaction guard. This is realy just 
      syntactic suggar arount a memento closure.
   """
   deep = False
   def __init__(self, *targets):
      self.targets = targets
      self.Commit()
   def Commit(self):
      self.states = [Memento(target, self.deep) for target in self.targets]
   def Rollback(self):
      for state in self.states:
         state()

class transactional(object):
   """Adds transactional semantics to methods. Methods decorated 
      with @transactional will rollback to entry state upon exceptions.
   """
   def __init__(self, method):
      self.method = method
   def __get__(self, obj, T):
      def transaction(*args, **kwargs):
         state = Memento(obj)
         try:
            return self.method(obj, *args, **kwargs)
         except:
            state()
            raise
      return transaction

if __name__ == '__main__':

   class NumObj(object):
      def __init__(self, value):
         self.value = value
      def __repr__(self):
         return '<%s: %r>' % (self.__class__.__name__, self.value)
      def Increment(self):
         self.value += 1
      @transactional
      def DoStuff(self):
         self.value = '1111' # <- invalid value
         self.Increment()    # <- will fail and rollback

   print
   n = NumObj(-1)
   print n
   t = Transaction(n)
   try:
      for i in range(3):
         n.Increment()
         print n
      t.Commit()
      print '-- commited'
      for i in range(3):
         n.Increment()
         print n
      n.value += 'x' # will fail
      print n
   except:
      t.Rollback()
      print '-- rolled back'
   print n
   print '-- now doing stuff ...'
   try:
      n.DoStuff()
   except:
      print '-> doing stuff failed!'
      import traceback
      traceback.print_exc(0)
      pass
   print n

Discussion:

Closures offer truly charming solution opportunities. In this example, the Memento function returns a closure that keeps the originator as well as the captured state in its scope, and restores the originator's state when called. Now, according to the memento pattern, the object representing the originator's state should be opaque, so the only thing you should be able to do with it is return it to the originator for state restoration. Well, I think the presented closure is as close (rem: note that subtle wording ;) to this definition as it can be.

Okay, we knew this was going to be easy with python. (After all, it seems to be the perfect design pattern implementation language, as you can almost always find a way to implement a pattern in a generic and reusable way.) And, once we've got it, we can build on top of it all sorts of useful (or at least nice-sounding ;) things:

- Transaction guards that work with multiple objects
- Decorators to add transactional action semantics to methods (a transactional action either entirely succeeds or fails w/o changing system state)
- Undo/Redo semantics (by swapping before/after states)
- ...

Cheers and happy transacting!

[See Also]
Memento pattern description at http://en.wikipedia.org/wiki/Memento_pattern