Django facilidad de construir una interfaz RESTful

Question

Estoy buscando una excusa para aprender Django para un nuevo proyecto que ha surgido. Por lo general, me gusta construir interfaces RESTful en el lado del servidor donde una URL se asigna a recursos que escuchan datos en algún contexto independiente de la plataforma, como XML o JSON. Esto es bastante sencillo de hacer sin el uso de marcos, pero algunos de ellos, como Ruby on Rails, le permiten fácilmente escupir XML a un cliente según el tipo de URL que pase, en función de su código de modelo existente.

Mi pregunta es, ¿algo como Django tiene soporte para esto? Busqué en Google y encontré un código de terceros "RESTful" que puede ir encima de Django. No estoy seguro de si estoy muy interesado en eso.

Si no es Django, ¿algún otro framework de Python que ya esté construido con esto en mente así que no tengo que reinventar la rueda como ya lo he hecho en lenguajes como PHP?

Answer 1

Esta es probablemente bastante fácil de hacer.

asignaciones de URL son fáciles de construir, por ejemplo:

urlpatterns = patterns('books.views', 
    (r'^books/$', 'index'), 
    (r'^books/(\d+)/$', 'get')) 

Django soporta model serialization, por lo que es fácil de convertir modelos en XML:

from django.core import serializers 
from models import Book 

data = serializers.serialize("xml", Book.objects.all()) 

combinar los dos con decorators y se puede construir Manipuladores rápidos y rápidos:

from django.http import HttpResponse 
from django.shortcuts import get_object_or_404 

def xml_view(func): 
    def wrapper(*args, **kwargs): 
    result = func(*args, **kwargs) 
    return HttpResponse(serializers.serialize("xml", result), 
     mimetype="text/xml") 
    return wrapper 

@xml_view 
def index(request): 
    return Books.objects.all() 

@xml_view 
def get(request, id): 
    return get_object_or_404(Book, pk=id) 

Answer 2

Puede responder con cualquier tipo de datos. JSON/XML/PDF/pictures/CSV ...

Django viene con un set of serializers.

Editar

acabo de tener un vistazo a al Piston - parece prometedor. Mejor característica:

Se mantiene fuera de su camino.

:)

Answer 3

A l Hace un año, escribí un servicio web REST en Django para una gran compañía de Seattle que hace streaming de medios en Internet.

Django fue excelente para este propósito. Como observó un "nerd pagado", la configuración de la URL de Django es maravillosa: puede configurar sus URL de la manera que desee y hacer que sirva los objetos apropiados.

Lo que no me gustó: el Django ORM no tiene absolutamente ningún soporte para BLOBs binarios. Si desea publicar fotografías o algo así, deberá guardarlas en un sistema de archivos y no en una base de datos. Debido a que estábamos usando varios servidores, tuve que elegir entre escribir mi propio soporte BLOB o encontrar algún marco de replicación que mantuviera todos los servidores actualizados con los últimos datos binarios. (Elegí escribir mi propio soporte BLOB. No fue muy difícil, así que en realidad me molestó que los chicos de Django no hicieran ese trabajo. Debería haber una, y preferiblemente solo una, forma obvia de hacer algo).

Me gusta mucho el Django ORM. Hace que la base de datos sea realmente fácil; no necesita saber any SQL.(No me gusta SQL y me gusta Python, así que es una doble ganancia). La "interfaz de administración", que obtienes de forma gratuita, te ofrece una excelente manera de revisar tus datos y meter datos durante las pruebas y desarrollo.

Recomiendo Django sin reserva.

Answer 4

Eche un vistazo a Piston, es un mini marco para Django para crear API RESTful.

Un reciente post de Eric Holscher proporciona cierta visión más clara sobre las ventajas de la utilización del pistón: Large Problems in Django, Mostly Solved: APIs

Answer 5

(. Tuve que editar los enlaces más evidentes)

1 de piston - (enlace encima). Yo había usado apibuilder (código abierto de Washington Times) en el pasado, pero Piston me resulta más fácil. Lo más difícil para mí es encontrar las estructuras de mi URL para la API y ayudar con las expresiones regulares. También he usado surlex, lo que hace que la tarea sea mucho más fácil.

ejemplo, el uso de este modelo para Group (de un sistema de calendario que estamos trabajando):

class Group(models.Model): 
    """ 
    Tree-like structure that holds groups that may have other groups as leaves. 
    For example ``st01gp01`` is part of ``stage1``. 
    This allows subgroups to work. The name is ``parents``, i.e.:: 

     >>> stage1group01 = Group.objects.get(unique_name = 'St 1 Gp01') 
     >>> stage1group01 
     >>> <Group: St 1 Gp01> 
     # get the parents... 
     >>> stage1group01.parents.all() 
     >>> [<Group: Stage 1>] 

    ``symmetrical`` on ``subgroup`` is needed to allow the 'parents' attribute to be 'visible'. 
    """ 
    subgroup = models.ManyToManyField("Group", related_name = "parents", symmetrical= False, blank=True) 
    unique_name = models.CharField(max_length=255) 
    name = models.CharField(max_length=255) 
    academic_year = models.CharField(max_length=255) 
    dept_id = models.CharField(max_length=255) 
    class Meta: 
     db_table = u'timetable_group' 
    def __unicode__(self): 
     return "%s" % self.name 

Y este fragmento urls.py (tenga en cuenta que surlex permite macros de expresiones regulares que se creará con facilidad) :

from surlex.dj import surl 
from surlex import register_macro 
from piston.resource import Resource 
from api.handlers import GroupHandler 
group_handler = Resource(GroupHandler) 

# add another macro to our 'surl' function 
# this picks up our module definitions 
register_macro('t', r'[\w\W ,-]+') 

urlpatterns = patterns('', 
# group handler 
# all groups 
url(r'^groups/$', group_handler), 
surl(r'^group/<id:#>/$', group_handler), 
surl(r'^group/<name:t>/$', group_handler),) 

A continuación, este controlador se verá después de la salida JSON (por defecto) y también puede hacer XML y YAML.

class GroupHandler(BaseHandler): 
    """ 
    Entry point for Group model 
    """ 

    allowed_methods = ('GET',) 
    model = Group 
    fields = ('id', 'unique_name', 'name', 'dept_id', 'academic_year', 'subgroup') 

    def read(self, request, id=None, name=None): 
     base = Group.objects 
     if id: 
      print self.__class__, 'ID' 
      try: 
       return base.get(id=id) 
      except ObjectDoesNotExist: 
       return rc.NOT_FOUND 
      except MultipleObjectsReturned: # Should never happen, since we're using a primary key. 
       return rc.BAD_REQUEST 
     else: 
      if name: 
       print self.__class__, 'Name' 
       return base.filter(unique_name = name).all() 
      else: 
       print self.__class__, 'NO ID' 
       return base.all() 

Como se puede ver, la mayor parte del código del controlador está en averiguar lo que se están pasando los parámetros en urlpatterns.

Algunas URL de ejemplo son api/groups/, api/group/3301/ y api/group/st1gp01/ - todas las cuales generarán JSON.

Answer 6

Con respecto a su comentario sobre que no le gusta el código de terceros, es una lástima porque las aplicaciones conectables son una de las mejores características de django. Al igual que otros respondieron, piston hará la mayor parte del trabajo por ti.