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
|
DB_PATH = './'
class BottleBucket(object): # pragma: no cover
""" Memory-caching wrapper around anydbm """
def __init__(self, name):
self.__dict__['name'] = name
self.__dict__['db'] = dbm.open(DB_PATH + '/%s.db' % name, 'c')
self.__dict__['mmap'] = {}
def __getitem__(self, key):
if key not in self.mmap:
self.mmap[key] = pickle.loads(self.db[key])
return self.mmap[key]
def __setitem__(self, key, value):
if not isinstance(key, str): raise TypeError("Bottle keys must be strings")
self.mmap[key] = value
def __delitem__(self, key):
if key in self.mmap:
del self.mmap[key]
del self.db[key]
def __getattr__(self, key):
try: return self[key]
except KeyError: raise AttributeError(key)
def __setattr__(self, key, value):
self[key] = value
def __delattr__(self, key):
try: del self[key]
except KeyError: raise AttributeError(key)
def __iter__(self):
return iter(self.ukeys())
def __contains__(self, key):
return key in self.ukeys()
def __len__(self):
return len(self.ukeys())
def keys(self):
return list(self.ukeys())
def ukeys(self):
return set(self.db.keys()) | set(self.mmap.keys())
def save(self):
self.close()
self.__init__(self.name)
def close(self):
for key in self.mmap:
pvalue = pickle.dumps(self.mmap[key], pickle.HIGHEST_PROTOCOL)
if key not in self.db or pvalue != self.db[key]:
self.db[key] = pvalue
self.mmap.clear()
if hasattr(self.db, 'sync'):
self.db.sync()
if hasattr(self.db, 'close'):
self.db.close()
def clear(self):
for key in self.db:
del self.db[key]
self.mmap.clear()
def update(self, other):
self.mmap.update(other)
def get(self, key, default=None):
try:
return self[key]
except KeyError:
if default:
return default
raise
class BottleDB(threading.local): # pragma: no cover
""" Holds multible BottleBucket instances in a thread-local way. """
def __init__(self):
self.__dict__['open'] = {}
def __getitem__(self, key):
warnings.warn("Please do not use bottle.db anymore. This feature is deprecated. You may use anydb directly.", DeprecationWarning)
if key not in self.open and not key.startswith('_'):
self.open[key] = BottleBucket(key)
return self.open[key]
def __setitem__(self, key, value):
if isinstance(value, BottleBucket):
self.open[key] = value
elif hasattr(value, 'items'):
if key not in self.open:
self.open[key] = BottleBucket(key)
self.open[key].clear()
for k, v in value.iteritems():
self.open[key][k] = v
else:
raise ValueError("Only dicts and BottleBuckets are allowed.")
def __delitem__(self, key):
if key not in self.open:
self.open[key].clear()
self.open[key].save()
del self.open[key]
def __getattr__(self, key):
try: return self[key]
except KeyError: raise AttributeError(key)
def __setattr__(self, key, value):
self[key] = value
def __delattr__(self, key):
try: del self[key]
except KeyError: raise AttributeError(key)
def save(self):
self.close()
self.__init__()
def close(self):
for db in self.open:
self.open[db].close()
self.open.clear()
db = BottleDB()
|
