/
request.py
466 lines (386 loc) · 16.7 KB
/
request.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
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
import json
from zope.deprecation import deprecate
from zope.deprecation.deprecation import deprecated
from zope.interface import implementer
from zope.interface.interface import InterfaceClass
from webob import BaseRequest
from pyramid.interfaces import (
IRequest,
IResponse,
ISessionFactory,
IResponseFactory,
)
from pyramid.compat import (
iterkeys_,
itervalues_,
iteritems_,
text_,
bytes_,
native_,
)
from pyramid.decorator import reify
from pyramid.response import Response
from pyramid.url import URLMethodsMixin
from pyramid.util import InstancePropertyMixin
class TemplateContext(object):
pass
class DeprecatedRequestMethodsMixin(object):
# b/c dict interface for "root factory" code that expects a bare
# environ. Explicitly omitted dict methods: clear (unnecessary),
# copy (implemented by WebOb), fromkeys (unnecessary); deprecated
# as of Pyramid 1.1.
dictlike = ('Use of the request as a dict-like object is deprecated as '
'of Pyramid 1.1. Use dict-like methods of "request.environ" '
'instead.')
@deprecate(dictlike)
def __contains__(self, k):
return self.environ.__contains__(k)
@deprecate(dictlike)
def __delitem__(self, k):
return self.environ.__delitem__(k)
@deprecate(dictlike)
def __getitem__(self, k):
return self.environ.__getitem__(k)
@deprecate(dictlike)
def __iter__(self):
return iter(self.environ)
@deprecate(dictlike)
def __setitem__(self, k, v):
self.environ[k] = v
@deprecate(dictlike)
def get(self, k, default=None):
return self.environ.get(k, default)
@deprecate(dictlike)
def has_key(self, k):
return k in self.environ
@deprecate(dictlike)
def items(self):
return self.environ.items()
@deprecate(dictlike)
def iteritems(self):
return iteritems_(self.environ)
@deprecate(dictlike)
def iterkeys(self):
return iterkeys_(self.environ)
@deprecate(dictlike)
def itervalues(self):
return itervalues_(self.environ)
@deprecate(dictlike)
def keys(self):
return self.environ.keys()
@deprecate(dictlike)
def pop(self, k):
return self.environ.pop(k)
@deprecate(dictlike)
def popitem(self):
return self.environ.popitem()
@deprecate(dictlike)
def setdefault(self, v, default):
return self.environ.setdefault(v, default)
@deprecate(dictlike)
def update(self, v, **kw):
return self.environ.update(v, **kw)
@deprecate(dictlike)
def values(self):
return self.environ.values()
# 1.0 deprecated bw compat code for using response_* values
rr_dep = ('Accessing and setting "request.response_%s" is '
'deprecated as of Pyramid 1.1; access or set '
'"request.response.%s" instead.')
# response_content_type
def _response_content_type_get(self):
return self._response_content_type
def _response_content_type_set(self, value):
self._response_content_type = value
def _response_content_type_del(self):
del self._response_content_type
response_content_type = property(_response_content_type_get,
_response_content_type_set,
_response_content_type_del)
response_content_type = deprecated(
response_content_type,
rr_dep % ('content_type', 'content_type'))
# response_headerlist
def _response_headerlist_get(self):
return self._response_headerlist
def _response_headerlist_set(self, value):
self._response_headerlist = value
def _response_headerlist_del(self):
del self._response_headerlist
response_headerlist = property(_response_headerlist_get,
_response_headerlist_set,
_response_headerlist_del)
hl_dep = ('Accessing and setting "request.response_headerlist" is '
'deprecated as of Pyramid 1.1; access the headerlist via '
'"request.response.headerlist" and extend headers via '
'"request.response.headerlist.extend(alist)" instead of '
'"request.response_headerlist = alist"')
response_headerlist = deprecated(response_headerlist, hl_dep)
# response_status
def _response_status_get(self):
return self._response_status
def _response_status_set(self, value):
self._response_status = value
def _response_status_del(self):
del self._response_status
response_status = property(_response_status_get,
_response_status_set,
_response_status_del)
response_status = deprecated(
response_status,
rr_dep % ('status', 'status'))
# response_charset
def _response_charset_get(self):
return self._response_charset
def _response_charset_set(self, value):
self._response_charset = value
def _response_charset_del(self):
del self._response_charset
response_charset = property(_response_charset_get,
_response_charset_set,
_response_charset_del)
response_charset = deprecated(
response_charset,
rr_dep % ('charset', 'charset'))
# response_cache_for
def _response_cache_for_get(self):
return self._response_cache_for
def _response_cache_for_set(self, value):
self._response_cache_for = value
def _response_cache_for_del(self):
del self._response_cache_for
response_cache_for = property(_response_cache_for_get,
_response_cache_for_set,
_response_cache_for_del)
response_cache_for = deprecated(
response_cache_for,
rr_dep % ('cache_for', 'cache_expires'))
class CallbackMethodsMixin(object):
response_callbacks = ()
finished_callbacks = ()
def add_response_callback(self, callback):
"""
Add a callback to the set of callbacks to be called by the
:term:`router` at a point after a :term:`response` object is
successfully created. :app:`Pyramid` does not have a
global response object: this functionality allows an
application to register an action to be performed against the
response once one is created.
A 'callback' is a callable which accepts two positional
parameters: ``request`` and ``response``. For example:
.. code-block:: python
:linenos:
def cache_callback(request, response):
'Set the cache_control max_age for the response'
response.cache_control.max_age = 360
request.add_response_callback(cache_callback)
Response callbacks are called in the order they're added
(first-to-most-recently-added). No response callback is
called if an exception happens in application code, or if the
response object returned by :term:`view` code is invalid.
All response callbacks are called *after* the
:class:`pyramid.events.NewResponse` event is sent.
Errors raised by callbacks are not handled specially. They
will be propagated to the caller of the :app:`Pyramid`
router application.
See also: :ref:`using_response_callbacks`.
"""
callbacks = self.response_callbacks
if not callbacks:
callbacks = []
callbacks.append(callback)
self.response_callbacks = callbacks
def _process_response_callbacks(self, response):
callbacks = self.response_callbacks
while callbacks:
callback = callbacks.pop(0)
callback(self, response)
def add_finished_callback(self, callback):
"""
Add a callback to the set of callbacks to be called
unconditionally by the :term:`router` at the very end of
request processing.
``callback`` is a callable which accepts a single positional
parameter: ``request``. For example:
.. code-block:: python
:linenos:
import transaction
def commit_callback(request):
'''commit or abort the transaction associated with request'''
if request.exception is not None:
transaction.abort()
else:
transaction.commit()
request.add_finished_callback(commit_callback)
Finished callbacks are called in the order they're added (
first- to most-recently- added). Finished callbacks (unlike
response callbacks) are *always* called, even if an exception
happens in application code that prevents a response from
being generated.
The set of finished callbacks associated with a request are
called *very late* in the processing of that request; they are
essentially the last thing called by the :term:`router`. They
are called after response processing has already occurred in a
top-level ``finally:`` block within the router request
processing code. As a result, mutations performed to the
``request`` provided to a finished callback will have no
meaningful effect, because response processing will have
already occurred, and the request's scope will expire almost
immediately after all finished callbacks have been processed.
Errors raised by finished callbacks are not handled specially.
They will be propagated to the caller of the :app:`Pyramid`
router application.
See also: :ref:`using_finished_callbacks`.
"""
callbacks = self.finished_callbacks
if not callbacks:
callbacks = []
callbacks.append(callback)
self.finished_callbacks = callbacks
def _process_finished_callbacks(self):
callbacks = self.finished_callbacks
while callbacks:
callback = callbacks.pop(0)
callback(self)
@implementer(IRequest)
class Request(BaseRequest, DeprecatedRequestMethodsMixin, URLMethodsMixin,
CallbackMethodsMixin, InstancePropertyMixin):
"""
A subclass of the :term:`WebOb` Request class. An instance of
this class is created by the :term:`router` and is provided to a
view callable (and to other subsystems) as the ``request``
argument.
The documentation below (save for the ``add_response_callback`` and
``add_finished_callback`` methods, which are defined in this subclass
itself, and the attributes ``context``, ``registry``, ``root``,
``subpath``, ``traversed``, ``view_name``, ``virtual_root`` , and
``virtual_root_path``, each of which is added to the request by the
:term:`router` at request ingress time) are autogenerated from the WebOb
source code used when this documentation was generated.
Due to technical constraints, we can't yet display the WebOb
version number from which this documentation is autogenerated, but
it will be the 'prevailing WebOb version' at the time of the
release of this :app:`Pyramid` version. See
http://pythonpaste.org/webob/ for further information.
"""
exception = None
exc_info = None
matchdict = None
matched_route = None
@reify
def tmpl_context(self):
# docs-deprecated template context for Pylons-like apps; do not
# remove.
return TemplateContext()
@reify
def session(self):
""" Obtain the :term:`session` object associated with this
request. If a :term:`session factory` has not been registered
during application configuration, a
:class:`pyramid.exceptions.ConfigurationError` will be raised"""
factory = self.registry.queryUtility(ISessionFactory)
if factory is None:
raise AttributeError(
'No session factory registered '
'(see the Sessions chapter of the Pyramid documentation)')
return factory(self)
@reify
def response(self):
"""This attribute is actually a "reified" property which returns an
instance of the :class:`pyramid.response.Response`. class. The
response object returned does not exist until this attribute is
accessed. Once it is accessed, subsequent accesses will return the
same Response object.
The ``request.response`` API is used by renderers. A render obtains
the response object it will return from a view that uses that renderer
by accessing ``request.response``. Therefore, it's possible to use the
``request.response`` API to set up a response object with "the
right" attributes (e.g. by calling ``request.response.set_cookie()``)
within a view that uses a renderer. Mutations to this response object
will be preserved in the response sent to the client."""
registry = self.registry
response_factory = registry.queryUtility(IResponseFactory,
default=Response)
return response_factory()
def is_response(self, ob):
""" Return ``True`` if the object passed as ``ob`` is a valid
response object, ``False`` otherwise."""
registry = self.registry
adapted = registry.queryAdapterOrSelf(ob, IResponse)
if adapted is None:
return False
return adapted is ob
@property
def json_body(self):
return json.loads(text_(self.body, self.charset))
def route_request_iface(name, bases=()):
# zope.interface treats the __name__ as the __doc__ and changes __name__
# to None for interfaces that contain spaces if you do not pass a
# nonempty __doc__ (insane); see
# zope.interface.interface.Element.__init__ and
# https://github.com/Pylons/pyramid/issues/232; as a result, always pass
# __doc__ to the InterfaceClass constructor.
iface = InterfaceClass('%s_IRequest' % name, bases=bases,
__doc__="route_request_iface-generated interface")
# for exception view lookups
iface.combined = InterfaceClass(
'%s_combined_IRequest' % name,
bases=(iface, IRequest),
__doc__ = 'route_request_iface-generated combined interface')
return iface
def add_global_response_headers(request, headerlist):
def add_headers(request, response):
for k, v in headerlist:
response.headerlist.append((k, v))
request.add_response_callback(add_headers)
def call_app_with_subpath_as_path_info(request, app):
# Copy the request. Use the source request's subpath (if it exists) as
# the new request's PATH_INFO. Set the request copy's SCRIPT_NAME to the
# prefix before the subpath. Call the application with the new request
# and return a response.
#
# Postconditions:
# - SCRIPT_NAME and PATH_INFO are empty or start with /
# - At least one of SCRIPT_NAME or PATH_INFO are set.
# - SCRIPT_NAME is not '/' (it should be '', and PATH_INFO should
# be '/').
environ = request.environ
script_name = environ.get('SCRIPT_NAME', '')
path_info = environ.get('PATH_INFO', '/')
subpath = list(getattr(request, 'subpath', ()))
new_script_name = ''
# compute new_path_info
new_path_info = '/' + '/'.join([native_(x.encode('utf-8'), 'latin-1')
for x in subpath])
if new_path_info != '/': # don't want a sole double-slash
if path_info != '/': # if orig path_info is '/', we're already done
if path_info.endswith('/'):
# readd trailing slash stripped by subpath (traversal)
# conversion
new_path_info += '/'
# compute new_script_name
workback = (script_name + path_info).split('/')
tmp = []
while workback:
if tmp == subpath:
break
el = workback.pop()
if el:
tmp.insert(0, text_(bytes_(el, 'latin-1'), 'utf-8'))
# strip all trailing slashes from workback to avoid appending undue slashes
# to end of script_name
while workback and (workback[-1] == ''):
workback = workback[:-1]
new_script_name = '/'.join(workback)
new_request = request.copy()
new_request.environ['SCRIPT_NAME'] = new_script_name
new_request.environ['PATH_INFO'] = new_path_info
# In case downstream WSGI app is a Pyramid app, hack around existence of
# these envars until we can safely remove them (see router.py); in any
# case, even if these get removed, it might be better to not copy the
# existing environ but to create a new one instead.
if 'bfg.routes.route' in new_request.environ:
del new_request.environ['bfg.routes.route']
if 'bfg.routes.matchdict' in new_request.environ:
del new_request.environ['bfg.routes.matchdict']
return new_request.get_response(app)