🔻 🐩 🧖🏼 थंडरगैस: उपयोग का अभ्यास। भाग 1 👨‍🚒 🛕 🤬

मैंने हाल ही में एक पोस्ट लिखी है कि कैसे वज्र का आविष्कार किया गया था और लिखा गया था। आज मैं इस बारे में बात करूंगा कि इसे कैसे लागू किया जा सकता है।

आपको याद दिला दूं कि यह बात एनोटेशन का उपयोग करके फ़ंक्शन मापदंडों को संसाधित करने के लिए डिज़ाइन की गई है। उदाहरण के लिए, इस तरह:

OPERATION = {'+': lambda x, y: x+y, '-': lambda x, y: xy, '*': lambda x, y: x*y, '/': lambda x, y: x/y, '^': lambda x, y: pow(x,y)} @Endpoint def calculate(x:Arg(int), y:Arg(int), op:Arg(str, default='+', expander=OPERATION)): return str(op(x,y))

हम ट्यूटोरियल के दौरान काफी विशिष्ट समस्याओं को हल करने की कोशिश करेंगे, और कुछ अल्पकालिक समस्याओं को नहीं। खैर, अब बात है।

आज सभी उदाहरणों (या लगभग सभी) में हम फ्लास्क का उपयोग करेंगे। जो लोग इस ढांचे से थोड़ा परिचित हैं वे अच्छी तरह जानते हैं कि रूपों से तर्क निकालने की समस्या दर्द और अपमान है। खैर, इसके अलावा, आखिरी विषय में, मैंने पहले से ही एक टुकड़ा लिखा था जो आपको अनावश्यक परेशानियों के साथ फ्लास्क के साथ थंडरगार्स का उपयोग करने की अनुमति देता है।

वैसे, आप यहां से उदाहरणों में सभी कोड उठा सकते हैं । आपको फ्लास्क-उदाहरण फ़ाइल की आवश्यकता है।

चलो चलते हैं

चरण 0: एनोटेशन सिंटैक्स, या जादू प्रभाव से छुटकारा पाएं

एनोटेशन सिंटैक्स के बारे में और अधिक पढ़ें।

और यहाँ हम केवल वही देखते हैं जिसकी हमें वास्तव में आवश्यकता है: तर्कों का वर्णन करने के लिए वाक्यविन्यास। यह इस तरह किया जाता है:

 def foo(a: expression, b: expression): ...

उसके बाद, हम __annotations__

फ़ंक्शन के __annotations__

फ़ील्ड के माध्यम से तर्कों के विवरण तक पहुंच सकते हैं:

 >>> def foo(a: "bar", b: 5+3): pass >>> foo.__annotations__ {'b': 8, 'a': 'bar'}

जैसा कि हम देख सकते हैं, यहाँ हमारे पास एनोटेट चर के नाम और शब्दकोश मूल्यों के रूप में गणना की गई अभिव्यक्तियाँ हैं। इसका मतलब यह है कि हम एनोटेशन में किसी भी मनमाने ढंग से अभिव्यक्त कर सकते हैं जो फ़ंक्शन की घोषणा के दौरान गणना की जाएगी। यह वह चिप है जिसका हम उपयोग करते हैं। यदि आप वास्तव में जानना चाहते हैं कि - पोस्ट को पढ़ने के लिए आपका स्वागत है, तो इसके लिए एक लिंक दिया गया है।

चरण 0.5: स्थापना

मैंने कुछ दोस्त के अनुरोध पर इस चीज़ को PyPI पर अपलोड किया है, इसलिए आप इसे सुरक्षित रूप से पाइप के माध्यम से स्थापित कर सकते हैं। एकमात्र सुधार: कुछ विशेषताएं जिन्हें हम मैनुअल में स्पर्श करेंगे वे केवल अल्फा संस्करण में हैं, इसलिए मैं उपयोग करने की सलाह देता --pre

: -

 sudo pip install thunderargs --pre

और फ्लास्क लगाना मत भूलना! सिद्धांत रूप में, थंडरगार्स को काम करने की आवश्यकता नहीं है, लेकिन वर्तमान मैनुअल में हम इसका उपयोग करेंगे।

चरण 1: प्राथमिक प्रकार कास्टिंग

थंडरार्ग्स के लिए सबसे सरल उपयोग का मामला टाइप कास्टिंग है। फ्लास्क में ऐसी एक अप्रिय विशेषता है: इसके पास पूर्व-तर्क के लिए कोई साधन नहीं है, और उन्हें सीधे समापन बिंदु कार्यों के शरीर में संसाधित किया जाना है।

मान लीजिए कि हम साधारण पेजिनेशन लिखना चाहते हैं। हमारे पास दो पैरामीटर होंगे: ऑफसेट और सीमा।

इसके लिए आवश्यक सभी प्रकार के डेटा को इंगित करना है, जिसके लिए ये तर्क दिए जाने चाहिए:

 from random import randrange from thunderargs.flask import Flask app = Flask() # Just a random sequence elements = list(map(lambda x: randrange(1000000), range(100))) @app.route('/step1') def step1(offset: Arg(int), limit: Arg(int)): return str(elements[offset:offset+limit]) if __name__ == '__main__': app.run(debug=True)

कृपया ध्यान दें कि इसके बाद मैं क्लासिक फ्लास्क का उपयोग नहीं करता हूं, लेकिन बदले हुए route

फ़ंक्शन के साथ संस्करण, जिसे मैं thunderargs.flask

से आयात करता हूं।

तो, हम एनोटेशन में जाति प्रकार रटना करने में सक्षम थे, और अब हमें इन जैसे बेवकूफ ऑपरेशन नहीं करना है:

  offset = int(request.args.get('offset')) limit = int(request.args.get('limit'))

समारोह के शरीर में। पहले से ही बुरा नहीं है। लेकिन परेशानी यह है: संभावनाओं के लिए अभी भी बड़ी संख्या में बेहिसाब है। यदि कोई नकारात्मक सीमा मान दर्ज करने का अनुमान लगाता है तो क्या होगा? अगर कोई कुछ भी नहीं कहता है तो क्या होगा? क्या होगा अगर कोई नंबर नहीं डालेगा? चिंता न करें, इन अपवादों से निपटने के लिए उपकरण हैं, और हम उन पर विचार करेंगे।

चरण 2: डिफ़ॉल्ट मान

जब तक हमारा वर्तमान उदाहरण हमें सूट करता है, तब तक हम कुछ भी नया नहीं करेंगे, हम सिर्फ इसके पूरक होंगे।

मेरी राय में, डिफ़ॉल्ट मान बहुत ही सहज रूप से सेट किए गए हैं:

 @app.route('/step2') def step2(offset: Arg(int, default=0), limit: Arg(int, default=20)): return str(elements[offset:offset+limit])

हम इस पर अधिक विस्तार से ध्यान नहीं देंगे। सिवाय, शायद, एक तथ्य: डिफ़ॉल्ट मान निर्दिष्ट वर्ग का एक उदाहरण होना चाहिए। हमारे मामले में, उदाहरण के लिए, [0,2,5]

डिफ़ॉल्ट मान के रूप में [0,2,5]

।

चरण 3: आवश्यक तर्क

 @app.route('/step3') def step3(username: Arg(required=True)): return "Hello, {}!".format(username)

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

और यदि आप सर्वर को आपके द्वारा आवश्यक तर्क नहीं देते हैं, तो आपको thunderargs.errors.ArgumentRequired

त्रुटि मिलेगी।

चरण 4: एकाधिक तर्क

यहां सब कुछ काफी स्पष्ट भी है। इसके अलावा, यह संभव है कि एक map object

एक पैरामीटर के रूप में हमारे कार्य में आएगा, सूची नहीं।

 @app.route('/step4') def step4(username: Arg(required=True, multiple=True)): return "Hello, {}!".format(" and ".join(", ".join(username).rsplit(', ', 1)))

यदि कोई पहले से ही भूल गया है, तो ऐसे तर्क हमें दिए जाते हैं जब उपयोगकर्ता एक नाम के लिए कई मान निर्दिष्ट करता है। अनुरोध उदाहरण:

 ?username=John&username=Adam&username=Lucas

बेशक, इस मामले में डिफ़ॉल्ट मूल्य को एक सूची के रूप में प्रस्तुत किया जाना चाहिए, और इस सूची के प्रत्येक तर्क को सभी शर्तों को पूरा करना होगा।

चरण 5: सत्यापनकर्ता

आइए हम अपने उदाहरण के लिए पेजिनेटर के साथ लौटते हैं, जिसे हमने मन में लाने का वादा किया था।

 from thunderargs.validfarm import val_gt, val_lt @app.route('/step5') def step5(offset: Arg(int, default=0, validators=[val_gt(-1), val_lt(len(elements))]), limit: Arg(int, default=20, validators=[val_lt(21)])): return str(elements[offset:offset+limit])

सत्यापनकर्ता एक कारखाने के खेत पर बने होते हैं जिसे वैधफल कहा जाता है। अब केवल सबसे आदिम विकल्प हैं, जैसे len_gt, val_neq और इतने पर, लेकिन भविष्य में, मुझे लगता है कि सूची को अपडेट किया जाएगा।

लेकिन कोई भी हमें अपना सत्यापनकर्ता बनाने के लिए परेशान नहीं करता है। यह केवल एक फ़ंक्शन होना चाहिए जो एक मान प्राप्त करता है और एक बूलियन प्रतिक्रिया देता है कि क्या यह मान इसे संतुष्ट करता है या नहीं।

 def step5(offset: Arg(int, default=0, validators=[lambda x: x >= 0 and x < len(elements)]), limit: Arg(int, default=20, validators=[val_lt(21)])): ...

या इस तरह भी:

 def less_than_21(x): return x < 21 @app.route('/step5_5') def step5_5(offset: Arg(int, default=0, validators=[lambda x: x >= 0 and x < len(elements)]), limit: Arg(int, default=20, validators=[less_than_21])): ...

सामान्य तौर पर, किसी भी चीज को बुलाया जा सकता है, जो तब काम कर सकती है जब उसके पास केवल एक तर्क दिया जाता है, और जो एक बूलियन उत्तर देता है, सत्यापनकर्ता के लिए करेगा।

चरण 6: तर्कों का विस्तार करें

अक्सर ऐसा होता है कि हमें एक उपयोगकर्ता से एक कुंजी प्राप्त करने की आवश्यकता होती है जो हमें बताती है कि हमें किस तर्क के साथ काम करना है। यह इस मामले के लिए है कि हमें एक स्कैन की आवश्यकता है।

प्रदर्शित करने के लिए, मैं फिर से वह फ़ंक्शन दूंगा जिसका मैंने पहले ही उल्लेख किया था। मुझे लगता है कि इस बार यहां सब कुछ साफ हो जाएगा।

 OPERATION = {'+': lambda x, y: x+y, '-': lambda x, y: xy, '*': lambda x, y: x*y, '^': lambda x, y: pow(x,y)} @app.route('/step6') def step6(x:Arg(int), y:Arg(int), op:Arg(str, default='+', expander=OPERATION)): return str(op(x,y))

जैसा कि आप देख सकते हैं, op

हमें उस कुंजी से खींचता है जो हमें उपयोगकर्ता से मिली थी।

expander

एक शब्दकोश या वस्तु कहा जा सकता है। वहां आप एक फ़ंक्शन को शॉफ़्ट कर सकते हैं, उदाहरण के लिए, निर्दिष्ट कुंजी का उपयोग करके डेटाबेस से हमारे लिए वांछित ऑब्जेक्ट निकालेंगे।

आज हम एक कार्यात्मक समीक्षा के साथ समाप्त करेंगे। केवल एक चीज मैं कुछ अतिरिक्त मैनुअल टिप्पणियां करना चाहूंगा।

अतिरिक्त टिप्पणियां

अजगर 2 या जीवाश्मों के लिए विकल्प

सिद्धांत रूप में, मैंने ऐसा कुछ भी इस्तेमाल नहीं किया जिससे इस सॉफ्टवेयर को दूसरे पायथन में ट्रांसफर करना असंभव हो जाए। स्ट्रिंग स्वरूपण को बदलने की आवश्यकता है। और, शायद, यह सब है। एनोटेशन का अनुकरण करने के लिए, thunderargs.endpoint

मॉड्यूल में एक साधारण डेकोरेटर है, जिसे annotate

कहा जाता है। संक्षेप में, इसे इस तरह उपयोग करें:

 @annotate(username=Arg()) def foo(username): ...

सिद्धांत रूप में, यह काम करना चाहिए, हालांकि व्यवहार में इसका परीक्षण नहीं किया गया है।

छोटे नोटों की कुप्पी

लेख में, हमने केवल जीईटी पद्धति पर विचार किया, लेकिन इसका मतलब यह नहीं है कि अन्य तरीके समर्थित नहीं हैं। मैंने इसे चुना ताकि परेशान न हो। लेकिन एक सूक्ष्मता है: मेरा मानना है कि एक उद्देश्य फ़ंक्शन के लिए कई विधियों की आवश्यकता नहीं है, और इसलिए, अब प्रत्येक फ़ंक्शन केवल एक विधि के लिए जिम्मेदार हो सकता है। मेरी राय में, यह कोड को अधिक पठनीय बनाता है।

यदि आपको अचानक एक देशी फ्लास्क रूटिंग की आवश्यकता है - app.froute

उपयोग app.froute

। लेकिन यह मत भूलो कि एनोटेशन टोकन वहां काम नहीं करते हैं।

सिद्धांत रूप में, अन्य फ्लास्क मॉड्यूल के साथ बातचीत को तोड़ना नहीं चाहिए। लेकिन अभ्यास दिखाएगा।

आप एक ही समय में एनोटेशन से दोनों पथ चर और मापदंडों का उपयोग कर सकते हैं। यदि कोई भी पैरामीटर दोनों नहीं है, तो वे एक-दूसरे के साथ संघर्ष नहीं करते हैं।

गैर-फ्लास्क पर छोटे नोट

यह याद रखना चाहिए कि गड़गड़ाहट बिना फ्लास्क के भी ठीक काम करती है। ऐसा करने के लिए, आपको फ़ंक्शन पर thunderargs.Endpoint

डेकोरेटर को thunderargs.Endpoint

से उपयोग करने की आवश्यकता है।

हालांकि, इसका दुरुपयोग न करें। दरअसल, हार्डकोर तर्क प्रसंस्करण केवल नियंत्रकों पर आवश्यक है।

यह मत भूलो कि आप आसानी से Arg

से अपने खुद के वंशज बना सकते हैं। इंट्राग, स्ट्रिंगएरग, बुलग्र और इतने पर। इस तरह के अनुकूलन फ़ंक्शन की घोषणा में वर्णों की संख्या को काफी कम कर सकते हैं और कोड पठनीयता बढ़ा सकते हैं।

हम इस पर काम कर रहे हैं।

अधिकांश कोड नशे में था। कुछ बहुत नींद की अवस्था में हैं। कोड को अनुकूलन की आवश्यकता है, लेकिन यह पहले से ही किसी तरह काम करता है। विकास और चल रहा है, इसलिए यदि आप अचानक मदद करने का निर्णय लेते हैं, तो सम्मिलित हों। कोई मदद मिलेगी, और विशेष रूप से परीक्षण। मैं, जैसा कि चुची के बारे में पुराने मज़ाक में, पाठक नहीं, बल्कि लेखक था। अब तक।

आप किसी भी सुझाव, इच्छाओं और आलोचना को यहाँ, टिप्पणियों में या यहाँ लिख सकते हैं ।

वैसे, मेरे बड़े अफ़सोस के साथ, मई अंग्रेजी से नोटों को बोना अच्छा है, जो अनुवाद पाठ लिखा है, इसलिए अगर कोई ऐसा करता है, तो मैं बहुत आभारी रहूंगा :)

दूसरा भाग थोड़ा गूढ़ होगा, लेकिन, जैसा कि मुझे आशा है, बहुत दिलचस्प है। लेकिन, दुर्भाग्य से, यह बहुत जल्द नहीं होगा।

थंडरगैस: उपयोग का अभ्यास। भाग 1