Decorators to wrap functions to make them WSGI applications.
The main decorator
wsgify turns a function into a WSGI
application (while also allowing normal calling of the method with an
wsgify(func=None, RequestClass=None, args=(), kwargs=None, middleware_wraps=None)¶
Turns a request-taking, response-returning function into a WSGI app
You can use this like:
@wsgify def myfunc(req): return webob.Response('hey there')
myfuncwill be a WSGI application, callable like
app_iter = myfunc(environ, start_response). You can also call it like normal, e.g.,
resp = myfunc(req). (You can also wrap methods, like
def myfunc(self, req).)
If you raise exceptions from
webob.excthey will be turned into WSGI responses.
There are also several parameters you can use to customize the decorator. Most notably, you can use a
class MyRequest(webob.Request): @property def is_local(self): return self.remote_addr == '127.0.0.1' @wsgify(RequestClass=MyRequest) def myfunc(req): if req.is_local: return Response('hi!') else: raise webob.exc.HTTPForbidden
Another customization you can add is to add args (positional arguments) or kwargs (of course, keyword arguments). While generally not that useful, you can use this to create multiple WSGI apps from one function, like:
import simplejson def serve_json(req, json_obj): return Response(json.dumps(json_obj), content_type='application/json') serve_ob1 = wsgify(serve_json, args=(ob1,)) serve_ob2 = wsgify(serve_json, args=(ob2,))
You can return several things from a function:
webob.Responseobject (or subclass)
- Any WSGI application
- None, and then
req.responsewill be used (a pre-instantiated Response object)
- A string, which will be written to
req.responseand then that response will be used.
- Raise an exception from
wsgify.middleware()for a way to make middleware.
You can also subclass this decorator; the most useful things to do in a subclass would be to change RequestClass or override call_func (e.g., to add
req.urlvarsas keyword arguments to the function).
call_func(req, *args, **kwargs)¶
Call the wrapped function; override this in a subclass to change how the function is called.
Creates a copy/clone of this object, but with some parameters rebound
Run a GET request on this application, returning a Response.
This creates a request object using the given URL, and any other keyword arguments are set on the request object (e.g.,
resp = myapp.get('/article?id=10')
middleware(middle_func=None, app=None, **kw)¶
Use this like:
@wsgify.middleware def restrict_ip(req, app, ips): if req.remote_addr not in ips: raise webob.exc.HTTPForbidden('Bad IP: %s' % req.remote_addr) return app @wsgify def app(req): return 'hi' wrapped = restrict_ip(app, ips=['127.0.0.1'])
Or as a decorator:
@restrict_ip(ips=['127.0.0.1']) @wsgify def wrapped_app(req): return 'hi'
Or if you want to write output-rewriting middleware:
@wsgify.middleware def all_caps(req, app): resp = req.get_response(app) resp.body = resp.body.upper() return resp wrapped = all_caps(app)
Note that you must call
req.get_response(app)to get a WebOb response object. If you are not modifying the output, you can just return the app.
As you can see, this method doesn't actually create an application, but creates "middleware" that can be bound to an application, along with "configuration" (that is, any other keyword arguments you pass when binding the application).
post(url, POST=None, **kw)¶
Run a POST request on this application, returning a Response.
The second argument (POST) can be the request body (a string), or a dictionary or list of two-tuples, that give the POST body.
resp = myapp.post('/article/new', dict(title='My Day', content='I ate a sandwich'))
Run a request on this application, returning a Response.
This can be used for DELETE, PUT, etc requests. E.g.:
resp = myapp.request('/article/1', method='PUT', body='New article')