class Action(object):
    """Describes an action, and a way to revert that action"""
 
    def __init__(self, do, undo):
        """Both do and undo are in the form (function, [arg1, arg2, ...])."""
        self._do = do
        self._undo = undo
 
    def do(self):
        fun, args = self._do
        return fun(*args)
 
    def undo(self):
        fun, args = self._undo
        return fun(*args)
 
 
class History(object):
    "Maintains a list of actions that can be undone and redone."
 
    def __init__(self):
        self._actions = []
        self._last = -1
 
    def _push(self, action):
        if self._last < len(self._actions) - 1:
            # erase previously undone actions
            del self._actions[self._last + 1:]
        self._actions.append(action)
        self._last = self._last + 1
 
    def undo(self):
        if self._last < 0:
            return None
        else:
            action = self._actions[self._last]
            self._last = self._last - 1
            return action.undo()
 
    def redo(self):
        if self._last == len(self._actions) - 1:
            return None
        else:
            self._last = self._last + 1
            action = self._actions[self._last]
            return action.do()
 
    def add(self, do, undo):
        """Does an action and adds it to history.
 
        Both do and undo are in the form (function, [arg1, arg2, ...]).
 
        """
        action = Action(do, undo)
        self._push(action)
        return action.do()

from history import History
 
h = History()

h.add(perform, revert)

h.undo()
h.redo()

def foo(x, y):
    ....
 
def unfoo(z):
    ....
 
perform = (foo, [arg1, arg2])
revert = (unfoo, [arg3])
 
h.add(perform, revert)

import history
 
d = {"x": 0, "y": 0}
h = history.History()
 
def modify(d, key, value):
    d[key] = value
 
def reset(d, saved):
    d.clear()
    d.update(saved)
 
saved = d.copy()
perform = (modify, [d, "x", 9999])
revert = (reset, [d, saved])
 
print "Original:  ", d
 
h.add(perform, revert)
print "Modified:  ", d
 
h.undo()
print "After undo:", d
 
h.redo()
print "After redo:", d

from history import History
 
class Calculator(object):
    def __init__(self):
	self.value = 0.
        self._history = History()
        self.undo = self._history.undo
        self.redo = self._history.redo
 
    def _operation(method):
        def decorated(self, n):
            saved = self.value
            perform = (method, (self, n))
            revert = (self._set_value, (saved,))
            self._history.add(perform, revert)
        return decorated
 
    def _set_value(self, n):
        self.value = n
 
    @_operation
    def add(self, n):
	self.value += n
 
    @_operation
    def sub(self, n):
	self.value -= n
 
    @_operation
    def mult(self, n):
        self.value *= n
 
    @_operation
    def div(self, n):
	self.value /= n
 
 
calculator = Calculator()
print "Initial value:", calculator.value
calculator.add(2)
print "+ 2 =", calculator.value
calculator.sub(3)
print "- 3 =", calculator.value
calculator.mult(5)
print "* 5 =", calculator.value
calculator.div(-2)
print "/ -2 =", calculator.value
 
print
 
for _ in range(4):
    calculator.undo()
    print "undo:", calculator.value
 
print
 
for _ in range(4):
    calculator.redo()
    print "redo:", calculator.value

import Queue
import threading
 
def command(method):
    """Decorator to enqueue method calls in Actor instances."""
    def enqueue_call(self, *args, **kwargs):
        args = list(args)
        args.insert(0, self)
        self._commands.put((method, args, kwargs))
    return enqueue_call
 
 
class Actor(threading.Thread):
    """A simple implementation of the active object design pattern."""
 
    def __init__(self):
        threading.Thread.__init__(self)
        self._commands = Queue.Queue()
        self._must_stop = False
 
    @command
    def stop(self):
        self._must_stop = True
 
    def run(self):
        while not self._must_stop:
            cmd, args, kwargs = self._commands.get()
            cmd(*args, **kwargs)
 
 
if __name__ == '__main__':
 
    import time
    class MyActor(Actor):
        @command
        def say(self, sentence):
            time.sleep(0.1)
            print sentence
 
    a = MyActor()
    a.start()
    a.say("Hello.")
    a.say("Bye.")
    a.stop()
    print "Main thread finished."