GeezerVison is showing github.com — python-patterns/memento.py at master · JimCormack/python-patterns

Expand file tree

memento.py

Copy path

More file actions

Latest commit

History

127 lines (102 loc) · 2.84 KB

memento.py

Copy path

File metadata and controls

127 lines (102 loc) · 2.84 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

#!/usr/bin/env python

# -*- coding: utf-8 -*-

"""http://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 '<%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

if __name__ == '__main__':

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 sys

import traceback

traceback.print_exc(file=sys.stdout)

pass

print(n)

### OUTPUT ###

# <NumObj: -1>

# <NumObj: 0>

# <NumObj: 1>

# <NumObj: 2>

# -- commited

# <NumObj: 3>

# <NumObj: 4>

# <NumObj: 5>

# -- rolled back

# <NumObj: 2>

# -- now doing stuff ...

# -> doing stuff failed!

# Traceback (most recent call last):

# File "memento.py", line 91, in <module>

# n.DoStuff()

# File "memento.py", line 47, in transaction

# return self.method(obj, *args, **kwargs)

# File "memento.py", line 67, in DoStuff

# self.Increment() # <- will fail and rollback

# File "memento.py", line 62, in Increment

# self.value += 1

# TypeError: Can't convert 'int' object to str implicitly

# <NumObj: 2>