-
Notifications
You must be signed in to change notification settings - Fork 1
/
runtime.py
399 lines (325 loc) · 12.6 KB
/
runtime.py
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
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
"""
runtime -- application runtime management
=========================================
This module provides a way to manage runtime in Python applicaitons.
Most of the code borrowed from the ``werkzeug.local`` by the Werkzeug Team.
:copyright:
(c) 2011 by the Werkzeug Team
(c) 2012 by Andrey Popp
:license: BSD
"""
import logging
# since each thread has its own greenlet we can just use those as identifiers
# for the context. If greenlets are not available we fall back to the
# current thread ident.
try:
from greenlet import getcurrent as get_ident # pylint: disable=F0401
except ImportError: # pragma: no cover
try:
from thread import get_ident
except ImportError: # pragma: no cover
from dummy_thread import get_ident
__all__ = (
'Context', 'Local', 'LocalStack', 'Proxy', 'release',
'current_object', 'is_bound')
class UnboundProxyError(RuntimeError):
""" Trying to access an object via an unbound proxy"""
class Context(object):
""" Context
This object represents a group of related objects exposed via proxies and
allows them to be managed as a stack.
"""
cleanup = None
def __init__(self, name=None, logging_name=None):
self.name = name
self.values = LocalStack()
self.proxies = {}
self.log = logging.getLogger(
'runtime.Context.%s' % (logging_name or name,))
def __getattr__(self, name):
""" Construct a new proxy which will be bound at configuration time"""
if name in self.proxies:
return self.proxies[name]
def _lookup():
try:
return self.values.value[name]
except (KeyError, AttributeError):
raise UnboundProxyError("object '%s' unbound" % name)
proxy = Proxy(_lookup)
self.proxies[name] = proxy
return proxy
def __str__(self):
try:
self.values.value
except UnboundProxyError:
initialized = False
else:
initialized = True
return "<%s '%s'%s>" % (
self.__class__.__name__,
self.name,
'' if initialized else ' uninitialized')
__repr__ = __str__
def __call__(self, **values):
""" Create a new session for context which implements context manager
protocol"""
return Session(self, values)
def overlay(self, **values):
try:
current = dict(self.values.value)
except UnboundProxyError:
current = {}
current.update(values)
return Session(self, current)
class Session(object):
def __init__(self, context, values):
self.context = context
self.values = values
def __enter__(self):
self.context.log.debug('entering context')
self.context.values.push(self.values)
return self
def __exit__(self, *args):
self.context.log.debug('exiting context')
if self.context.cleanup:
self.context.cleanup()
self.context.values.pop()
class Local(object):
__slots__ = ('__storage__', '__ident_func__')
def __init__(self):
object.__setattr__(self, '__storage__', {})
object.__setattr__(self, '__ident_func__', get_ident)
def __iter__(self):
return iter(self.__storage__.items())
def __call__(self, proxy):
"""Create a proxy for a name."""
def _lookup():
try:
return getattr(self, proxy)
except AttributeError:
raise UnboundProxyError("object '%s' unbound" % proxy)
return Proxy(_lookup)
def __release__(self):
self.__storage__.pop(self.__ident_func__(), None)
def __getattr__(self, name):
try:
return self.__storage__[self.__ident_func__()][name]
except KeyError:
raise AttributeError(name)
def __setattr__(self, name, value):
ident = self.__ident_func__()
storage = self.__storage__
try:
storage[ident][name] = value
except KeyError:
storage[ident] = {name: value}
def __delattr__(self, name):
try:
del self.__storage__[self.__ident_func__()][name]
except KeyError:
raise AttributeError(name)
class LocalStack(object):
"""This class works similar to a :class:`.Local` but keeps a stack
of objects instead. This is best explained with an example::
>>> ls = LocalStack()
>>> ls.push(42)
>>> ls.value
42
>>> ls.push(23)
>>> ls.value
23
>>> ls.pop()
23
>>> ls.value
42
They can be force released by using a :class:`Manager` or with
the :func:`release` function but the correct way is to pop the
item from the stack after using. When the stack is empty it will
no longer be bound to the current context (and as such released).
By calling the stack without arguments it returns a proxy that resolves to
the topmost item on the stack.
"""
def __init__(self):
self._local = Local()
def __release__(self):
release(self._local)
def _get__ident_func__(self):
return self._local.__ident_func__
def _set__ident_func__(self, value):
object.__setattr__(self._local, '__ident_func__', value)
__ident_func__ = property(_get__ident_func__, _set__ident_func__)
del _get__ident_func__, _set__ident_func__
def push(self, obj):
"""Pushes a new item to the stack"""
rv = getattr(self._local, 'stack', None)
if rv is None:
self._local.stack = rv = [] # pylint: disable=W0201
rv.append(obj)
return rv
def pop(self):
"""Removes the topmost item from the stack, will return the
old value or `None` if the stack was already empty.
"""
stack = getattr(self._local, 'stack', None)
if stack is None:
return None
elif len(stack) == 1:
release(self._local)
return stack[-1]
else:
return stack.pop()
@property
def value(self):
"""The topmost item on the stack. If the stack is empty,
`None` is returned.
"""
try:
return self._local.stack[-1]
except (AttributeError, IndexError):
raise UnboundProxyError('object unbound')
class Proxy(object):
"""Acts as a proxy for a werkzeug local. Forwards all operations to
a proxied object. The only operations not supported for forwarding
are right handed operands and any kind of assignment.
Example usage::
from werkzeug.local import Local
l = Local()
# these are proxies
request = l('request')
user = l('user')
from werkzeug.local import LocalStack
_response_local = LocalStack()
# this is a proxy
response = _response_local()
Whenever something is bound to l.user / l.request the proxy objects
will forward all operations. If no object is bound a
:exc:`UnboundProxyError` will be raised.
To create proxies to :class:`Local` or :class:`LocalStack` objects,
call the object as shown above. If you want to have a proxy to an
object looked up by a function, you can (as of Werkzeug 0.6.1) pass
a function to the :class:`Proxy` constructor::
session = Proxy(lambda: get_current_request().session)
"""
__slots__ = ('__lookup', '__dict__',)
def __init__(self, lookup=None):
object.__setattr__(self, '_Proxy__lookup', lookup)
def __current_object__(self):
"""Return the current object. This is useful if you want the real
object behind the proxy at a time for performance reasons or because
you want to pass the object into a different context.
"""
return self.__lookup()
def __set_lookup__(self, lookup):
object.__setattr__(self, '_Proxy__lookup', lookup)
@property
def __dict__(self):
try:
return self.__current_object__().__dict__
except UnboundProxyError:
raise AttributeError('__dict__')
def __repr__(self):
try:
obj = self.__current_object__()
except UnboundProxyError:
return '<%s unbound>' % self.__class__.__name__
return repr(obj)
def __nonzero__(self):
try:
return bool(self.__current_object__())
except UnboundProxyError:
return False
def __unicode__(self):
try:
return unicode(self.__current_object__())
except UnboundProxyError:
return repr(self)
def __dir__(self):
try:
return dir(self.__current_object__())
except UnboundProxyError:
return []
def __getattr__(self, name):
if name == '__members__':
return dir(self.__current_object__())
return getattr(self.__current_object__(), name)
def __setitem__(self, key, value):
self.__current_object__()[key] = value
def __delitem__(self, key):
del self.__current_object__()[key]
def __setslice__(self, i, j, seq):
self.__current_object__()[i:j] = seq
def __delslice__(self, i, j):
del self.__current_object__()[i:j]
__setattr__ = lambda x, n, v: setattr(x.__current_object__(), n, v)
__delattr__ = lambda x, n: delattr(x.__current_object__(), n)
__str__ = lambda x: str(x.__current_object__())
__lt__ = lambda x, o: x.__current_object__() < o
__le__ = lambda x, o: x.__current_object__() <= o
__eq__ = lambda x, o: x.__current_object__() == o
__ne__ = lambda x, o: x.__current_object__() != o
__gt__ = lambda x, o: x.__current_object__() > o
__ge__ = lambda x, o: x.__current_object__() >= o
__cmp__ = lambda x, o: cmp(x.__current_object__(), o)
__hash__ = lambda x: hash(x.__current_object__())
__call__ = lambda x, *a, **kw: x.__current_object__()(*a, **kw)
__len__ = lambda x: len(x.__current_object__())
__getitem__ = lambda x, i: x.__current_object__()[i]
__iter__ = lambda x: iter(x.__current_object__())
__contains__ = lambda x, i: i in x.__current_object__()
__getslice__ = lambda x, i, j: x.__current_object__()[i:j]
__add__ = lambda x, o: x.__current_object__() + o
__sub__ = lambda x, o: x.__current_object__() - o
__mul__ = lambda x, o: x.__current_object__() * o
__floordiv__ = lambda x, o: x.__current_object__() // o
__mod__ = lambda x, o: x.__current_object__() % o
__divmod__ = lambda x, o: x.__current_object__().__divmod__(o)
__pow__ = lambda x, o: x.__current_object__() ** o
__lshift__ = lambda x, o: x.__current_object__() << o
__rshift__ = lambda x, o: x.__current_object__() >> o
__and__ = lambda x, o: x.__current_object__() & o
__xor__ = lambda x, o: x.__current_object__() ^ o
__or__ = lambda x, o: x.__current_object__() | o
__div__ = lambda x, o: x.__current_object__().__div__(o)
__truediv__ = lambda x, o: x.__current_object__().__truediv__(o)
__neg__ = lambda x: -(x.__current_object__())
__pos__ = lambda x: +(x.__current_object__())
__abs__ = lambda x: abs(x.__current_object__())
__invert__ = lambda x: ~(x.__current_object__())
__complex__ = lambda x: complex(x.__current_object__())
__int__ = lambda x: int(x.__current_object__())
__long__ = lambda x: long(x.__current_object__())
__float__ = lambda x: float(x.__current_object__())
__oct__ = lambda x: oct(x.__current_object__())
__hex__ = lambda x: hex(x.__current_object__())
__index__ = lambda x: x.__current_object__().__index__()
# pylint: disable=W0108
__coerce__ = lambda x, o: x.__current_object__().__coerce__(x, o)
__enter__ = lambda x: x.__current_object__().__enter__()
__exit__ = lambda x, *a, **kw: x.__current_object__().__exit__(*a, **kw)
def current_object(proxy):
""" Return object proxy currently points to"""
return proxy.__current_object__()
def is_bound(proxy):
""" Return ``True`` if ``proxy`` is bound to some value"""
try:
current_object(proxy)
except UnboundProxyError:
return False
else:
return True
def release(local):
"""Releases the contents of the local for the current context.
This makes it possible to use locals without a manager.
Example::
>>> loc = Local()
>>> loc.foo = 42
>>> release(loc)
>>> hasattr(loc, 'foo')
False
With this function one can release :class:`Local` objects as well
as :class:`StackLocal` objects. However it is not possible to
release data held by proxies that way, one always has to retain
a reference to the underlying local object in order to be able
to release it.
"""
local.__release__()