def traversal_path(path):
""" Variant of :func:`pyramid.traversal.traversal_path_info` suitable for
decoding paths that are URL-encoded.
If this function is passed a Unicode object instead of a sequence of
bytes as ``path``, that Unicode object *must* directly encodeable to
ASCII. For example, u'/foo' will work but u'/<unprintable unicode>' (a
Unicode object with characters that cannot be encoded to ascii) will
not. A :exc:`UnicodeEncodeError` will be raised if the Unicode cannot be
encoded directly to ASCII.
"""
if isinstance(path, text_type):
# must not possess characters outside ascii
path = path.encode("ascii")
# we unquote this path exactly like a PEP 3333 server would
path = unquote_bytes_to_wsgi(path) # result will be a native string
return traversal_path_info(path) # result will be a tuple of unicode
def traversal_path(path):
""" Variant of :func:`pyramid.traversal.traversal_path_info` suitable for
decoding paths that are URL-encoded.
If this function is passed a Unicode object instead of a sequence of
bytes as ``path``, that Unicode object *must* directly encodeable to
ASCII. For example, u'/foo' will work but u'/<unprintable unicode>' (a
Unicode object with characters that cannot be encoded to ascii) will
not. A :exc:`UnicodeEncodeError` will be raised if the Unicode cannot be
encoded directly to ASCII.
"""
if isinstance(path, text_type):
# must not possess characters outside ascii
path = path.encode('ascii')
# we unquote this path exactly like a PEP 3333 server would
path = unquote_bytes_to_wsgi(path) # result will be a native string
return traversal_path_info(path) # result will be a tuple of unicode
def embed(request, *elements, **kw):
""" as_user=True for current user
"""
# Should really be more careful about what gets included instead.
# Cache cut response time from ~800ms to ~420ms.
as_user = kw.get('as_user')
path = join(*elements)
path = unquote_bytes_to_wsgi(native_(path))
if as_user is not None:
result, embedded, linked = _embed(request, path, as_user)
else:
cached = embed_cache.get(path, None)
if cached is None:
cached = _embed(request, path)
embed_cache[path] = cached
result, embedded, linked = cached
result = deepcopy(result)
request._embedded_uuids.update(embedded)
request._linked_uuids.update(linked)
return result
def embed(request, *elements, **kw):
""" as_user=True for current user
"""
# Should really be more careful about what gets included instead.
# Cache cut response time from ~800ms to ~420ms.
as_user = kw.get('as_user')
path = join(*elements)
path = unquote_bytes_to_wsgi(native_(path))
log.debug('embed: %s', path)
if as_user is not None:
result, embedded, linked = _embed(request, path, as_user)
else:
cached = embed_cache.get(path, None)
if cached is None:
cached = _embed(request, path)
embed_cache[path] = cached
result, embedded, linked = cached
result = deepcopy(result)
request._embedded_uuids.update(embedded)
request._linked_uuids.update(linked)
return result
def embed(request, *elements, **kw):
"""
Incredibly important function that is central to getting views in snovault.
Since it is a reified method on Request, you can call it like:
`request.embed(<elements to be joined in path>)`
This function handles propogation of important request attrs to subrequests,
as well as caching of requests and grabbing attrs from the subreq result.
Check connection.py and cache.py for details on the embed_cache
NOTES:
path is formed by joining all positional args
as_user=True for current user
Pass in fields_to_embed as a keyword arg
Args:
request: Request calling this method
*elements: variable length positional args used to make path
**kw: arbitrary keyword arguments
Returns:
result of the invoked request
"""
# Should really be more careful about what gets included instead.
# Cache cut response time from ~800ms to ~420ms.
embed_cache = request.registry[CONNECTION].embed_cache
as_user = kw.get('as_user')
index_uuid = kw.get('index_uuid')
path = join(*elements)
path = unquote_bytes_to_wsgi(native_(path))
# as_user controls whether or not the embed_cache is used
# if request._indexing_view is True, always use the cache
if as_user is not None and not request._indexing_view:
cached = _embed(request, path, as_user)
else:
cached = embed_cache.get(path, None)
if cached is None:
# handle common cases of as_user, otherwise use what's given
subreq_user = '******' if as_user is None else as_user
cached = _embed(request, path, as_user=subreq_user)
# caching audits is safe because they don't add to linked_uuids
embed_cache[path] = cached
# NOTE: if result was retrieved from ES, the following cached attrs will be
# empty: _aggregated_items, _linked_uuids, _rev_linked_by_item
result = deepcopy(cached['result'])
# aggregated_items may be cached; if so, add them to the request
# these conditions only fulfilled when using @@embedded and aggregated
# items have NOT yet been processed (_aggregate_for is removed if so)
if index_uuid and getattr(request, '_aggregate_for').get('uuid') == index_uuid:
request._aggregated_items = cached['_aggregated_items']
request._aggregate_for['uuid'] = None
# hardcode this because audits can cause serious problems with frame=page
if '@@audit' not in path:
request._linked_uuids.update(cached['_linked_uuids'])
request._sid_cache.update(cached['_sid_cache'])
# this is required because rev_linked_uuids_by_item is formatted as
# a dict keyed by item with value of set of uuids rev linking to that item
for item, rev_links in cached['_rev_linked_by_item'].items():
if item in request._rev_linked_uuids_by_item:
request._rev_linked_uuids_by_item[item].update(rev_links)
else:
request._rev_linked_uuids_by_item[item] = rev_links
return result
