FilesExpand file tree

 master

/

memento.py

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

127 lines (102 loc) · 2.84 KB

 master

/

memento.py

Copy path

Top

File metadata and controls

• Code
• Blame

127 lines (102 loc) · 2.84 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

92

93

94

95

96

97

98

99

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>