Recommandations du cadre Python REST (services Web)?
Existe-t-il une liste de recommandations de différents frameworks REST basés sur Python à utiliser sur le côté serveur pour écrire vos propres API RESTful? De préférence avec des avantages et des inconvénients.
N'hésitez pas à ajouter des recommandations ici. :)
Il convient d’être prudent lors de la conception d’une API RESTful: l’assemblage de GET et de POST, comme si c’était la même chose. Il est facile de commettre cette erreur avec les répartiteurs par défaut de Djangoà base de fonctions et CherryPy , bien que les deux frameworks offrent maintenant un moyen de contourner ce problème ( vues basées sur les classes et MethodDispatcher , respectivement).
Les verbes HTTP sont très importants dans REST, et si vous ne faites pas très attention à cela, vous finirez par tomber dans un REST anti-pattern .
Certains cadres qui fonctionnent correctement sont web.py , Flask et Bottle . Lorsqu'elles sont combinées avec la bibliothèque mimerender (divulgation complète: je l'ai écrite), elles vous permettent d'écrire de beaux services Web RESTful:
import web
import json
from mimerender import mimerender
render_xml = lambda message: '<message>%s</message>'%message
render_json = lambda **args: json.dumps(args)
render_html = lambda message: '<html><body>%s</body></html>'%message
render_txt = lambda message: message
urls = (
'/(.*)', 'greet'
)
app = web.application(urls, globals())
class greet:
@mimerender(
default = 'html',
html = render_html,
xml = render_xml,
json = render_json,
txt = render_txt
)
def GET(self, name):
if not name:
name = 'world'
return {'message': 'Hello, ' + name + '!'}
if __== "__main__":
app.run()
La logique du service est mise en œuvre une seule fois, et la sélection de représentation correcte (en-tête Accepter) + l'envoi à la fonction de rendu (ou modèle) appropriée sont effectués de manière claire et transparente.
$ curl localhost:8080/x
<html><body>Hello, x!</body></html>
$ curl -H "Accept: application/html" localhost:8080/x
<html><body>Hello, x!</body></html>
$ curl -H "Accept: application/xml" localhost:8080/x
<message>Hello, x!</message>
$ curl -H "Accept: application/json" localhost:8080/x
{'message':'Hello, x!'}
$ curl -H "Accept: text/plain" localhost:8080/x
Hello, x!
Mise à jour (avril 2012) : ajout d'informations sur les vues basées sur les classes de Django, les frameworks MethodDispatcher et Flasket Bottle de CherryPy. Ni existait à l'époque où la question a été posée.
Surpris personne n'a mentionné ballon .
from flask import Flask
app = Flask(__name__)
@app.route("/")
def hello():
return "Hello World!"
if __== "__main__":
app.run()
Nous utilisons Django pour les services Web RESTful.
Notez que - immédiatement - Django n'avait pas une authentification suffisamment fine pour nos besoins. Nous avons utilisé l'interface Django-REST , qui a beaucoup aidé. [Nous avons depuis lancé notre propre projet parce que nous avions fait tellement d'extensions que c'était devenu un cauchemar de maintenance.]
Nous avons deux types d'URL: les URL "html" qui implémentent les pages HTML à orientation humaine et les URL "json" qui implémentent le traitement orienté services Web. Nos fonctions de vue ressemblent souvent à ceci.
def someUsefulThing( request, object_id ):
# do some processing
return { a dictionary with results }
def htmlView( request, object_id ):
d = someUsefulThing( request, object_id )
render_to_response( 'template.html', d, ... )
def jsonView( request, object_id ):
d = someUsefulThing( request, object_id )
data = serializers.serialize( 'json', d['object'], fields=EXPOSED_FIELDS )
response = HttpResponse( data, status=200, content_type='application/json' )
response['Location']= reverse( 'some.path.to.this.view', kwargs={...} )
return response
Le fait est que la fonctionnalité utile est prise en compte dans les deux présentations. La présentation JSON est généralement un seul objet demandé. La présentation HTML inclut souvent toutes sortes d’aides à la navigation et d’autres indices contextuels permettant aux utilisateurs d’être productifs.
Les fonctions jsonView sont toutes très similaires, ce qui peut être un peu gênant. Mais c'est du Python, alors intégrez-les à une classe appelable ou écrivez des décorateurs si cela vous aide.
Voir Frameworks Web Python wiki.
Vous n'avez probablement pas besoin des frameworks de pile complète , mais la liste restante est encore longue.
Jeter un coup d'œil à
J'aime vraiment CherryPy . Voici un exemple de service Web reposant:
import cherrypy
from cherrypy import expose
class Converter:
@expose
def index(self):
return "Hello World!"
@expose
def fahr_to_celc(self, degrees):
temp = (float(degrees) - 32) * 5 / 9
return "%.01f" % temp
@expose
def celc_to_fahr(self, degrees):
temp = float(degrees) * 9 / 5 + 32
return "%.01f" % temp
cherrypy.quickstart(Converter())
Cela souligne ce que j’aime vraiment chez CherryPy; C'est un exemple complètement fonctionnel qui est très compréhensible même pour quelqu'un qui ne connaît pas le framework. Si vous exécutez ce code, vous pouvez immédiatement voir les résultats dans votre navigateur Web. par exemple. visit http: // localhost: 8080/celc_to_fahr? degrés = 5 affichera 122.0 dans votre navigateur Web.
Je ne vois aucune raison d'utiliser Django simplement pour exposer une REST api, il existe des solutions plus légères et plus flexibles. Django apporte beaucoup d'autres choses à la table, qui ne sont pas toujours nécessaires. Bien sûr, inutile si vous souhaitez uniquement exposer du code en tant que service REST.
Mon expérience personnelle, fwiw, est qu'une fois que vous avez un framework unique, vous commencerez à utiliser son ORM, ses plugins, etc. juste parce que c'est facile, et en un rien de temps, vous finirez par avoir une dépendance. c'est très difficile de s'en débarrasser.
Le choix d'un framework Web est une décision difficile, et j'éviterais de choisir une solution complète pour empiler simplement pour exposer une API REST.
Maintenant, si vous avez vraiment besoin/voulez utiliser Django, alors Piston est un framework Nice REST pour Django applications.
Ceci étant dit, CherryPy a vraiment l’air beau, mais semble plus RPC que REST.
En regardant les exemples (je ne l'ai jamais utilisé), probablement web.py est le meilleur et le plus propre si vous avez seulement besoin de REST.
En 2010, les communautés Pylons et Repoze.bfg ont uni leurs forces pour créer Pyramid , un framework Web basé principalement sur repoze.bfg. Il conserve les philosophies de ses cadres parents et peut être utilisé pour services RESTful . Ça vaut le coup d'oeil.
Voici une discussion dans la documentation CherryPy sur REST: http://docs.cherrypy.org/dev/progguide/REST.html
En particulier, il mentionne un répartiteur CherryPy intégré appelé MethodDispatcher, qui appelle des méthodes en fonction de leurs identificateurs de verbe HTTP (GET, POST, etc.).
Il semble que tous les types de python structures Web puissent désormais mettre en œuvre des interfaces RESTful.
Pour Django, à part la saveur et le piston, Django-reste-cadre est un cadre prometteur à mentionner. J'ai déjà migré l'un de mes projets en douceur.
Django REST est un framework léger REST pour Django, qui vise à faciliter la création d'API Web RESTful bien connectées et auto-descriptives.
Exemple rapide:
from Django.conf.urls.defaults import patterns, url
from djangorestframework.resources import ModelResource
from djangorestframework.views import ListOrCreateModelView, InstanceModelView
from myapp.models import MyModel
class MyResource(ModelResource):
model = MyModel
urlpatterns = patterns('',
url(r'^$', ListOrCreateModelView.as_view(resource=MyResource)),
url(r'^(?P<pk>[^/]+)/$', InstanceModelView.as_view(resource=MyResource)),
)
Prenez l'exemple du site officiel, tous les codes ci-dessus fournissent une api, un document auto-explicatif (comme un service Web à base de savon) et même un bac à sable pour tester un peu. Très pratique.
Piston est un framework très flexible pour l'écriture d'API RESTful pour Django applications.
Je ne suis pas un expert du monde python, mais j'utilise Django , qui est un excellent framework Web et peut être utilisé pour créer un framework reposant.
web2py inclut le support pour la construction facile d'API RESTful, décrit ici et ici (vidéo). En particulier, regardez parse_as_rest , qui vous permet de définir des modèles d’URL qui mappent les arguments de requête aux requêtes de base de données; et smart_query , qui vous permet de transmettre des requêtes arbitraires en langage naturel dans l'URL.
Si vous utilisez Django, vous pouvez alors envisager Django-tastypie comme alternative à Django-piston . Il est plus facile d’accorder des sources de données non-ORM que piston, et a un excellent documentation .
Je recommande fortement TurboGears ou Bottle:
TurboGears:
- moins verbeux que Django
- plus flexible, moins orienté HTML
- mais: moins célèbre
Bouteille:
- très vite
- très facile à apprendre
- mais: minimaliste et pas mature
Nous travaillons sur un cadre pour les services REST stricts, consultez http://prestans.googlecode.com
C'est au début Alpha pour le moment, nous testons contre mod_wsgi et AppEngine de Google.
Vous cherchez des testeurs et des commentaires. Merci.