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
128
129
130
131
132
133
134
135
136
137
138
|
import unittest
import collections
from . import InMemoryDatabase
class DictProxy(collections.MutableMapping):
def __init__(self):
self.store = {}
def __len__(self):
return len(self.store)
def __iter__(self):
return iter(self.store)
def __getitem__(self, key):
return self.store[key]
def __setitem__(self, key, new_value):
self.store[key] = new_value
def __delitem__(self, key):
del self.store[key]
class PythonTest(unittest.TestCase):
def test_accessor_generation(self):
class AccessorsDict(DictProxy):
def __setitem__(self, key, new_value):
if not callable(new_value):
self.store["get_" + key] = lambda self: getattr(self, key)
super().__setitem__(key, new_value)
class AccessorsMetaclass(type):
@classmethod
def __prepare__(metacls, name, bases, **kwds):
return AccessorsDict()
def __new__(cls, name, bases, namespace, **kwds):
return super().__new__(cls, name, bases, namespace.store)
class Point(object, metaclass=AccessorsMetaclass):
x = 0
y = 0
def distance(self):
import math
return math.sqrt(pow(self.get_x(), 2) + pow(self.get_y(), 2))
point = Point()
point.x = 3
point.y = 4
assert point.get_x() == 3
assert point.get_y() == 4
assert point.distance() == 5
def test_trace_method_calls(self):
methods_called = []
class TraceDict(DictProxy):
def __setitem__(self, key, new_value):
if callable(new_value):
def trace_wrapper(self, *args, **kwargs):
methods_called.append(new_value.__name__)
return new_value(self, *args, **kwargs)
to_set = trace_wrapper
else:
to_set = new_value
super().__setitem__(key, to_set)
class TraceClass(type):
@classmethod
def __prepare__(metacls, name, bases, **kwds):
return TraceDict()
def __new__(cls, name, bases, namespace, **kwds):
return super().__new__(cls, name, bases, namespace.store)
class Point(object, metaclass=TraceClass):
def get_x(self):
return self.x
def get_y(self):
return self.y
point = Point()
point.x = 2
point.y = 3
assert methods_called == []
assert point.get_x() == 2
assert methods_called == ['get_x']
assert point.get_y() == 3
assert methods_called == ['get_x', 'get_y']
def test_db_backed_object(self):
class DatabaseDict(DictProxy):
def __init__(self, db):
super().__init__()
self.store["db"] = db
def __getattr__(self, name):
db_key = str(hash(self)) + ":" + name
return self.db.lookup(db_key)
self.store["__getattr__"] = __getattr__
def __setattr__(self, name, new_value):
db_key = str(hash(self)) + ":" + name
self.db.insert(db_key, new_value)
self.store["__setattr__"] = __setattr__
class DatabaseBackedClass(type):
@classmethod
def __prepare__(metacls, name, bases, **kwds):
return DatabaseDict(kwds["db"])
def __new__(cls, name, bases, namespace, **kwds):
return super().__new__(cls, name, bases, namespace.store)
def __init__(cls, name, bases, namespace, **kwds):
super().__init__(name, bases, namespace)
class Point(object, metaclass=DatabaseBackedClass, db=InMemoryDatabase()):
def get_x(self):
return self.x
def get_y(self):
return self.y
def set_x(self, new_value):
self.x = new_value
point = Point()
point.x = 3
point.y = 7
assert point.get_x() == 3
assert point.get_y() == 7
assert point.__dict__ == {}
point.set_x(12)
assert point.get_x() == 12
assert point.get_y() == 7
assert point.__dict__ == {}
assert len(Point.db.store) == 2
point2 = Point()
point2.x = 123
point2.y = -5
assert point.get_x() == 12
assert point.get_y() == 7
assert point.__dict__ == {}
assert point2.get_x() == 123
assert point2.get_y() == -5
assert point2.__dict__ == {}
assert len(Point.db.store) == 4
|
