Integrating with a Framework ============================ General considerations ---------------------- Using WSME within another framework providing its own REST capabilities is generally done by using a specific decorator to declare the function signature, in addition to the framework own way of declaring exposed functions. This decorator can have two different names depending on the adapter. ``@wsexpose`` This decorator will declare the function signature *and* take care of calling the adequate decorators of the framework. Generally this decorator is provided for frameworks that use object-dispatch controllers, such as :ref:`adapter-pecan` and :ref:`adapter-tg1`. ``@signature`` This decorator only set the function signature and returns a function that can be used by the host framework as a REST request target. Generally this decorator is provided for frameworks that expects functions taking a request object as a single parameter and returning a response object. This is the case of :ref:`adapter-cornice` and :ref:`adapter-flask`. Additionnaly, if you want to enable additionnal protocols, you will need to mount a :class:`WSRoot` instance somewhere in the application, generally ``/ws``. This subpath will then handle the additional protocols. In a future version, a wsgi middleware will probably play this role. .. note:: Not all the adapters are at the same level of maturity. WSGI Application ---------------- The :func:`wsme.WSRoot.wsgiapp` function of WSRoot returns a wsgi application. Example ~~~~~~~ The following example assume the REST protocol will be entirely handled by WSME, which is the case if you write a WSME standalone application. .. code-block:: python from wsme import WSRoot, expose class MyRoot(WSRoot): @expose(unicode) def helloworld(self): return u"Hello World !" root = MyRoot(protocols=['restjson']) application = root.wsgiapp() .. _adapter-cornice: Cornice ------- .. _cornice: http://cornice.readthedocs.org/en/latest/ *"* Cornice_ *provides helpers to build & document REST-ish Web Services with Pyramid, with decent default behaviors. It takes care of following the HTTP specification in an automated way where possible."* :mod:`wsmeext.cornice` -- Cornice adapter ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ .. module:: wsmeext.cornice .. function:: signature Declare the parameters of a function and returns a function suitable for cornice (ie that takes a request and returns a response). Example ~~~~~~~ .. code-block:: python from cornice import Service from wsmeext.cornice import signature import wsme.types hello = Service(name='hello', path='/', description="Simplest app") class Info(wsme.types.Base): message = wsme.types.text @hello.get() @signature(Info) def get_info(): """Returns Hello in JSON or XML.""" return Info(message='Hello World') @hello.post() @signature(None, Info) def set_info(info): print("Got a message: %s" % info.message) .. _adapter-flask: Flask ----- *"Flask is a microframework for Python based on Werkzeug, Jinja 2 and good intentions. And before you ask: It's BSD licensed! "* .. warning:: Flask support is limited to function signature handling. It does not support additional protocols. This is a temporary limitation, if you have needs on that matter please tell us at python-wsme@googlegroups.com. :mod:`wsmeext.flask` -- Flask adapter ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ .. module:: wsmeext.flask .. function:: signature(return_type, \*arg_types, \*\*options) See @\ :func:`signature` for parameters documentation. Can be used on a function before routing it with flask. Example ~~~~~~~ .. code-block:: python from wsmeext.flask import signature @app.route('/multiply') @signature(int, int, int) def multiply(a, b): return a * b .. _adapter-pecan: Pecan ----- *"*\ Pecan_ *was created to fill a void in the Python web-framework world – a very lightweight framework that provides object-dispatch style routing. Pecan does not aim to be a "full stack" framework, and therefore includes no out of the box support for things like sessions or databases. Pecan instead focuses on HTTP itself."* .. warning:: A pecan application is not able to mount another wsgi application on a subpath. For that reason, additional protocols are not supported for now, ie until wsme provides a middleware that can do the same as a mounted WSRoot. :mod:`wsmeext.pecan` -- Pecan adapter ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ .. module:: wsmeext.pecan .. function:: wsexpose(return_type, \*arg_types, \*\*options) See @\ :func:`signature` for parameters documentation. Can be used on any function of a pecan `RestController `_ instead of the expose decorator from Pecan. Configuration ~~~~~~~~~~~~~ WSME can be configured through the application configation, by adding a 'wsme' configuration entry in ``config.py``: .. code-block:: python wsme = { 'debug': True } Valid configuration variables are : - ``'debug'``: Wether or not to include exception tracebacks in the returned server-side errors. Example ~~~~~~~ The `example `_ from the Pecan documentation becomes: .. code-block:: python from wsmeext.pecan import wsexpose class BooksController(RestController): @wsexpose(Book, int, int) def get(self, author_id, id): # .. @wsexpose(Book, int, int, body=Book) def put(self, author_id, id, book): # .. class AuthorsController(RestController): books = BooksController() .. _Pecan: http://pecanpy.org/ .. _adapter-tg1: Turbogears 1.x -------------- The TG adapters have an api very similar to TGWebServices. Migrating from it should be straightforward (a little howto migrate would not hurt though, and it will be written as soon as possible). :mod:`wsmeext.tg11` -- TG 1.1 adapter ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ .. module:: wsmeext.tg11 .. function:: wsexpose(return_type, \*arg_types, \*\*options) See @\ :func:`signature` for parameters documentation. Can be used on any function of a controller instead of the expose decorator from TG. .. function:: wsvalidate(\*arg_types) Set the argument types of an exposed function. This decorator is provided so that WSME is an almost drop-in replacement for TGWebServices. If starting from scratch you can use \ :func:`wsexpose` only .. function:: adapt(wsroot) Returns a TG1 controller instance that publish a :class:`wsme.WSRoot`. It can then be mounted on a TG1 controller. Because the adapt function modifies the cherrypy filters of the controller the 'webpath' of the WSRoot instance must be consistent with the path it will be mounted on. :mod:`wsmeext.tg15` -- TG 1.5 adapter ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ .. module:: wsmeext.tg15 This adapter has the exact same api as :mod:`wsmeext.tg11`. Example ~~~~~~~ In a freshly quickstarted tg1 application (let's say, wsmedemo), you can add REST-ish functions anywhere in your controller tree. Here directly on the root, in controllers.py: .. code-block:: python # ... # For tg 1.5, import from wsmeext.tg15 instead : from wsmeext.tg11 import wsexpose, WSRoot class Root(controllers.RootController): # Having a WSRoot on /ws is only required to enable additional # protocols. For REST-only services, it can be ignored. ws = adapt( WSRoot(webpath='/ws', protocols=['soap']) ) @wsexpose(int, int, int) def multiply(self, a, b): return a * b .. _TurboGears: http://www.turbogears.org/ Other frameworks ---------------- Bottle ~~~~~~ No adapter is provided yet but it should not be hard to write one, by taking example on the cornice adapter. This example only show how to mount a WSRoot inside a bottle application. .. code-block:: python import bottle import wsme class MyRoot(wsme.WSRoot): @wsme.expose(unicode) def helloworld(self): return u"Hello World !" root = MyRoot(webpath='/ws', protocols=['restjson']) bottle.mount('/ws', root.wsgiapp()) bottle.run() Pyramid ~~~~~~~ The recommended way of using WSME inside Pyramid is to use :ref:`adapter-cornice`.