python - पायथन आरईएसटी(वेब सेवाओं) ढांचे की सिफारिशें?




web-services rest (11)

क्या आपके स्वयं के रीस्टफुल एपीआई लिखने के लिए सर्वरसाइड पर उपयोग के लिए अलग-अलग पायथन-आधारित आरईएसटी ढांचे की सिफारिशों की कहीं सूची है? पेशेवरों और विपक्ष के साथ पसंदीदा रूप से।

कृपया यहां सिफारिशें जोड़ने के लिए स्वतंत्र महसूस करें। :)


2010 में, पिलोन और repoze.bfg समुदायों ने Pyramid बनाने के लिए "बलों में शामिल हो गए", एक वेब ढांचा repoze.bfg पर सबसे अधिक आधारित है। यह अपने मूल ढांचे के दर्शन को बरकरार रखता है, और इसका उपयोग रीस्टफुल सेवाओं के लिए किया जा सकता है। यह एक लायक है।


Django अनुप्रयोगों के लिए रीस्टफुल एपीआई wirting के लिए Piston बहुत लचीला ढांचा है।


आश्चर्यचकित कोई flask उल्लेख नहीं किया।

from flask import Flask
app = Flask(__name__)

@app.route("/")
def hello():
    return "Hello World!"

if __name__ == "__main__":
    app.run()

एक विश्वसनीय एपीआई डिजाइन करते समय सावधान रहना कुछ है, जीईटी और पोस्ट का उलझन, जैसे कि वे एक ही बात थे। Django के फ़ंक्शन-आधारित दृश्यों और CherryPy के डिफ़ॉल्ट प्रेषक के साथ यह गलती करना आसान है, हालांकि दोनों ढांचे अब इस समस्या के आसपास एक रास्ता प्रदान करते हैं (क्रमशः कक्षा-आधारित विचार और MethodDispatcher )।

आरईएसटी में HTTP-क्रियाएं बहुत महत्वपूर्ण हैं , और जब तक आप इसके बारे में बहुत सावधान नहीं हैं, तो आप एक आरईएसटी विरोधी पैटर्न में गिरने लगेंगे

कुछ ढांचे जो इसे सही web.py हैं वे web.py , flask और बोतल हैं । जब mimerender लाइब्रेरी के साथ मिलकर (पूर्ण प्रकटीकरण: मैंने इसे लिखा), वे आपको अच्छे mimerender लिखने की अनुमति देते हैं:

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 __name__ == "__main__":
    app.run()

सेवा का तर्क केवल एक बार लागू किया जाता है, और सही प्रतिनिधित्व चयन (हेडर स्वीकार करें) + उचित रेंडर फ़ंक्शन (या टेम्पलेट) पर प्रेषण एक साफ, पारदर्शी तरीके से किया जाता है।

$ 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!

अपडेट (अप्रैल 2012) : Django के क्लास-आधारित विचारों, चेरीपी के मेथड डिस्पैचर और फ्लास्क और बोतल ढांचे के बारे में अतिरिक्त जानकारी। जब सवाल पूछा गया था तब भी अस्तित्व में नहीं था।


मुझे केवल एक आरईएसटी एपीआई का पर्दाफाश करने के लिए Django का उपयोग करने का कोई कारण नहीं दिखता है, हल्का और अधिक लचीला समाधान है। Django टेबल पर कई अन्य चीजें रखता है, जो हमेशा की जरूरत नहीं है। निश्चित रूप से जरूरी नहीं है अगर आप केवल कुछ कोड को आरईएसटी सेवा के रूप में बेनकाब करना चाहते हैं।

मेरा व्यक्तिगत अनुभव, fwiw, यह है कि एक बार आपके पास एक आकार-फिट-सभी ढांचे के बाद, आप अपने ओआरएम, इसके प्लगइन्स इत्यादि का उपयोग करना शुरू कर देंगे क्योंकि यह आसान है, और किसी भी समय आप निर्भरता को समाप्त नहीं करते हैं इससे छुटकारा पाने के लिए बहुत मुश्किल है।

वेब ढांचे का चयन करना एक कठिन निर्णय है, और मैं एक आरईएसटी एपीआई का पर्दाफाश करने के लिए एक पूर्ण स्टैक समाधान चुनने से बचूंगा।

अब, यदि आपको वास्तव में Django का उपयोग करना / चाहते हैं, तो पिस्टन डीजेंगो ऐप्स के लिए एक अच्छा आरईएसटी ढांचा है।

ऐसा कहा जा रहा है, चेरीपी वास्तव में भी अच्छा लग रहा है, लेकिन आरईएसटी की तुलना में अधिक आरपीसी लगता है।

नमूने को देखकर (मैंने इसका कभी भी उपयोग नहीं किया), शायद आपको सबसे अच्छा और साफ-सुथरा है यदि आपको केवल REST की आवश्यकता है।


मुझे वास्तव में CherryPy पसंद है। यहां एक आराम से वेब सेवा का एक उदाहरण दिया गया है:

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

यह मुझे चेरीपी के बारे में वास्तव में पसंद करने पर जोर देता है; यह एक पूरी तरह से काम करने वाला उदाहरण है जो कि किसी ऐसे व्यक्ति को भी समझ में आता है जो ढांचे को नहीं जानता है। यदि आप यह कोड चलाते हैं, तो आप तुरंत अपने वेब ब्राउज़र में परिणाम देख सकते हैं; उदाहरण के लिए http://localhost:8080/celc_to_fahr?degrees=50 आपके वेब ब्राउज़र में 122.0 प्रदर्शित करेगा।


मैं अजगर की दुनिया पर एक विशेषज्ञ नहीं हूं लेकिन मैं Django का उपयोग कर रहा हूं जो एक उत्कृष्ट वेब ढांचा है और इसका उपयोग एक स्थिर ढांचा बनाने के लिए किया जा सकता है।


मैं दृढ़ता से टर्बोगियर्स या बोतल की सलाह देता हूं:

TurboGears:

  • django से कम verbose
  • अधिक लचीला, कम HTML- उन्मुख
  • लेकिन: कम प्रसिद्ध

बोतल:

  • बहुत तेज़
  • सीखना बहुत आसान है
  • लेकिन: minimalistic और परिपक्व नहीं

हम रीस्टफुल वेब सेवाओं के लिए Django का उपयोग कर रहे हैं।

ध्यान दें कि - बॉक्स के बाहर - Django हमारे आवश्यकताओं के लिए पर्याप्त प्रमाणीकरण नहीं था। हमने Django-REST इंटरफ़ेस का उपयोग किया, जिसने बहुत मदद की। [हमने तब से अपना खुद का लुत्फ उठाया है क्योंकि हमने इतने सारे एक्सटेंशन बनाए हैं कि यह एक रखरखाव दुःस्वप्न बन गया था।]

हमारे पास दो प्रकार के यूआरएल हैं: "एचटीएमएल" यूआरएल जो मानव उन्मुख HTML पृष्ठों को लागू करता है, और "जेसन" यूआरएल जो वेब-सर्विसेज उन्मुख प्रोसेसिंग को कार्यान्वित करता है। हमारे विचार कार्य अक्सर इस तरह दिखते हैं।

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

मुद्दा यह है कि उपयोगी प्रस्तुति दो प्रस्तुतियों में से एक है। JSON प्रस्तुति आमतौर पर केवल एक ऑब्जेक्ट है जिसे अनुरोध किया गया था। एचटीएमएल प्रस्तुति में अक्सर सभी प्रकार के नेविगेशन एड्स और अन्य प्रासंगिक संकेत शामिल होते हैं जो लोगों को उत्पादक बनने में मदद करते हैं।

jsonView फ़ंक्शन सभी समान हैं, जो थोड़ा परेशान हो सकते हैं। लेकिन यह पाइथन है, इसलिए यदि उन्हें मदद मिलती है तो उन्हें कॉल करने योग्य वर्ग का हिस्सा बनाएं या सजावट लिखें।


हम सख्त आरईएसटी सेवाओं के लिए एक ढांचे पर काम कर रहे हैं, http://prestans.googlecode.com देखें

फिलहाल अल्फा में, हम mod_wsgi और Google के AppEngine के खिलाफ परीक्षण कर रहे हैं।

परीक्षकों और प्रतिक्रिया की तलाश में। धन्यवाद।


web2py में here और here (वीडियो) वर्णित, RESTful API के आसानी से निर्माण के लिए समर्थन शामिल है। विशेष रूप से, parse_as_rest , जो आपको यूआरएल पैटर्न को परिभाषित करने देता है जो नक्शा अनुरोध डेटाबेस parse_as_rest देता है; और smart_query , जो आपको यूआरएल में मनमाने ढंग से प्राकृतिक भाषा प्रश्नों को पारित करने में सक्षम बनाता है।





frameworks