Django facilità di costruire un'interfaccia RESTful

Question

Sto cercando una scusa per imparare Django per un nuovo progetto che è venuto fuori. In genere mi piace creare interfacce lato server RESTful in cui un URL si associa alle risorse che trasmettono dati in un contesto indipendente dalla piattaforma, come XML o JSON. Questo è piuttosto semplice da fare senza l'uso di framework, ma alcuni di essi, come Ruby on Rails, ti consentono di sputare facilmente XML a un client in base al tipo di URL che hai passato, in base al codice del tuo modello esistente.

La mia domanda è: qualcosa come Django supporta questo? Ho cercato su google e ho trovato un codice di terze parti 'RESTful' che può andare in cima a Django. Non sono sicuro se sono troppo entusiasta di ciò.

Se no Django, qualsiasi altro framework Python che è già stato creato con questo in mente, quindi non devo reinventare la ruota come ho già fatto in lingue come PHP?

Answer 1

Questo è probabilmente abbastanza facile da fare.

mappature URL sono facili da costruire, per esempio:

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

Django supporta model serialization, quindi è facile per trasformare i modelli in XML:

from django.core import serializers 
from models import Book 

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

combinare i due con decorators e si può costruire gestori rapidi e veloci:

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

Può rispondere con qualsiasi tipo di dati. JSON/XML/PDF/immagini/CSV ...

Django stesso viene fornito con un set of serializers.

Modifica

Ho appena dato un'occhiata a al Piston - sembra essere molto promettente. La migliore caratteristica:

Soggiorna fuori mano.

:)

Answer 3

A l Più di un anno fa, ho scritto un servizio web REST in Django per una grande azienda di Seattle che fa streaming multimediale su Internet.

Django era eccellente per lo scopo. Come osservato da "un nerd pagato", la configurazione dell'URL di Django è meravigliosa: puoi impostare i tuoi URL nel modo in cui li desideri e farli servire agli oggetti appropriati.

L'unica cosa che non mi piace: l'ORM Django non ha assolutamente alcun supporto per i BLOB binari. Se vuoi servire delle foto o qualcosa del genere, dovrai tenerle in un file system e non in un database. Dato che stavamo usando più server, dovevo scegliere tra scrivere il mio supporto BLOB o trovare qualche framework di replica che tenesse tutti i server aggiornati con gli ultimi dati binari. (Ho scelto di scrivere il mio supporto per i BLOB. Non era molto difficile, quindi ero davvero seccato che i ragazzi di Django non lo avessero fatto, ci dovrebbe essere uno, e preferibilmente un solo, ovvio modo di fare qualcosa.)

Mi piace molto l'ORM Django. Rende la parte del database davvero semplice; non è necessario conoscere qualsiasi SQL.(Non mi piace SQL e mi piace Python, quindi è una doppia vittoria.) L '"interfaccia di amministrazione", che ottieni gratuitamente, ti offre un ottimo modo per esaminare i tuoi dati e per attirare dati durante i test e sviluppo.

Raccomando Django senza prenotazione.

Answer 4

Dai un'occhiata a Piston, è un mini-framework per Django per la creazione di API RESTful.

Un recente post sul blog di Eric Holscher fornisce un po 'di comprensione sui pro di utilizzare Pistone: Large Problems in Django, Mostly Solved: APIs

Answer 5

(. Ho dovuto modificare i link più evidenti)

+1 per piston - (link sopra). In passato avevo usato apibuilder (fonte aperta di Washington Times), ma l'Piston per me è più semplice. La cosa più difficile per me è capire le mie strutture URL per l'API e aiutare con le espressioni regolari. Ho anche usato surlex che rende questo compito molto più facile.

esempio, utilizzando questo modello per Group (da un sistema di calendario a cui stiamo lavorando):

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 

E questo frammento urls.py (si noti che surlex permette macro espressioni regolari da istituire facilmente) :

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),) 

Poi questo gestore si prenderà cura di uscita JSON (per impostazione predefinita) e possono anche fare XML e 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() 

Come potete vedere, la maggior parte del codice di gestione è a capire quali parametri vengono passati in urlpatterns.

Alcuni URL di esempio sono api/groups/, api/group/3301/ e api/group/st1gp01/ - che emetteranno tutti JSON.

Answer 6

Per quanto riguarda il tuo commento sul non piacere codice di terze parti - è un peccato perché le app pluggable sono una delle migliori funzionalità di django. Come altri hanno risposto, pistone farà la maggior parte del lavoro per te.