A better pattern for ajax loading with pyramid?

Question

I've read up on using different renderers or overriding renderer but I'm wondering if there's a better way to handle this pattern.

Right now, in my view I'm returning a set of items to the template:

@view_config(
    route_name = 'name',
    permission = 'perm',
    renderer   = 'r.mako'
)
def r( request ):
     items = get_items()
     return { 'items': items }

Now I want the ajax version to just renderer a subset of it, also with some data. My current working code:

@view_config(
    route_name = 'name',
    permission = 'perm',
    renderer   = 'r.mako'
)
def r( request ):
     items = get_items()

     if ajax:
         return Response( to_json( {
                             'data1':  1,
                             'data2':  2,
                             'data3':  3,
                             'html':  renderers.render( 'shortr.mako',
                                                        { 'items': items },
                                                        request )
                         } )

     return { 'items': items }

I guess specifically I wonder if there's a cleaner way to override the renderer and then wrap it in something, without explicitly calling render and making sure I got the dict right or request as a param. thanks

Michael Merickel · Accepted Answer · 2011-12-21T22:15:01.310

I would suggest using 2 views which properly allow you to apply a different "look-and-feel" (responses) to the same data.

def get_items(request):
    return {} # values that you can pick and choose from in each view

@view_config(route_name='name', permission='perm', xhr=True, renderer='json')
def r_ajax(request):
    items = get_items(request)
    return {
        'data1': 1, 'data2': 2, 'data3': 3,
        'html': renderers.render('shortr.mako', {'items': items}, request),
    }

@view_config(route_name='name', permission='perm', renderer='r.mako')
def r_html(request):
    items = get_items(request)
    return items

If you're afraid of repeating things for the view configuration, Pyramid 1.3 comes with a cool new feature on its class-based views:

@view_defaults(route_name='name', permission='perm')
class R(object):
    def __init__(self, request):
        self.request = request
        self.items = # ...

    @view_config(xhr=True, renderer='json')
    def ajax(request):
        return {
            'data1': 1, 'data2': 2, 'data3': 3,
            'html': renderers.render('shortr.mako', {'items': items}, request),
        }

    @view_config(renderer='r.mako')
    def html(request):
        return self.items

thanks, i thought about this, but I guess I was wondering if there's a way to simplify the `renderers.render( ... )` part so that it wraps easier.. but I guess not — Timmy, Dec 22 '11 at 00:02
I'm sorry but as I read through your question I don't see how that particular line was the focus. Anyway if you're using a custom mako renderer as part of a json response that's fairly weird and I'm not sure how you're expecting that to get any prettier. — Michael Merickel, Dec 22 '11 at 07:24

score 1 · Answer 2 · answered Dec 21 '11 at 19:12

I'm not familiar with pyramid or what 'r.mako' is referencing, but you could probably hook in to the request before the controller is called with a custom function that inspects the Accepts headers of the request, looking for 'text/javascript' or 'application/json' as the foremost Accepts, and then set a flag on the request object (or have that method factored out for use in your r function).

Then do a custom renderer to handle either parsing with mako or dumping a json string

# pseudo-code
def before_controller(request, response):
    if 'text/html' in request.headers.accepts:
        request.is_json = False
    elif 'application/json' in request.headers.accepts:
        response.headers.set('Content-type', 'application/json')
        request.is_json = True

# pseudo-code
def my_renderer(request, response, result):
    if 'text/html' in request.headers.accepts:
        return # render html
    elif 'application/json' in request.headers.accepts:
        response.headers.set('Content-type', 'application/json')
        return json.dumps(result)

#
def r(request):
    items = get_items()
    if request.json:
        pass # update items with additional data
    return {'items': items} # one point of return

The method would also mean no extra leg-work if you dont need to do any additional processing on items, you simply return the result as normal and receive the json object on the other end.

If you cant hook into pyramid before the controller is called, you could write a convenience function to call is_json(request) and use that in the controller and the renderer for determining output and setting content-type header

A better pattern for ajax loading with pyramid?

2 Answers2