'''code.activestate.com/recipes/413838-memento-closure/'''

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 really 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 st in self.states:
         st()

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


class NumObj(object):
   def __init__(self, value):
      self.value = value

   def __repr__(self):
      return '' % (self.__class__.__name__, self.value)

   def Increment(self):
      self.value += 1

   @transactional
   def DoStuff(self):
      self.value = '1111' #