FilesExpand file tree

 master

/

memento.py

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

91 lines (75 loc) · 2.01 KB

 master

/

memento.py

Copy path

Top

File metadata and controls

• Code
• Blame

91 lines (75 loc) · 2.01 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

'''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 traceback

traceback.print_exc(0)

pass

print(n)