ट्रेलो बोर्ड प्रबंधन के लिए पायथन सीएलआई प्रोग्राम कैसे बनाएं (भाग 1)

मैंने बेहतरीन एनिमेशन वाले विभिन्न सीएलआई सॉफ़्टवेयर देखे हैं, और इसने मुझे आश्चर्यचकित कर दिया - क्या मैं कभी अपने 'मिनिमलिस्टिक' रॉक-पेपर-कैंची स्कूल प्रोजेक्ट को अपग्रेड कर सकता हूँ?

नमस्ते, चलो खेलें! अपना फाइटर चुनें (चट्टान, कागज, कैंची): चट्टान

सीएलआई कार्यक्रम क्या है?

जैसा कि विकिपीडिया पर कहा गया है, "कमांड-लाइन इंटरफ़ेस (सीएलआई) किसी डिवाइस या कंप्यूटर प्रोग्राम के साथ उपयोगकर्ता या क्लाइंट के कमांड और टेक्स्ट की पंक्तियों के रूप में डिवाइस या प्रोग्राम से प्रतिक्रियाओं के साथ इंटरैक्ट करने का एक साधन है।"

दूसरे शब्दों में, सीएलआई प्रोग्राम एक ऐसा प्रोग्राम है जिसके तहत उपयोगकर्ता निष्पादित करने के लिए निर्देश प्रदान करके प्रोग्राम के साथ बातचीत करने के लिए कमांड लाइन का उपयोग करता है।

कई दैनिक सॉफ़्टवेयर को सीएलआई प्रोग्राम के रूप में लपेटा जाता है। उदाहरण के लिए vim टेक्स्ट एडिटर को लें - किसी भी UNIX सिस्टम के साथ भेजा गया एक टूल जिसे टर्मिनल में vim <FILE> चलाकर सक्रिय किया जा सकता है।

Google क्लाउड सीएलआई के संबंध में, आइए सीएलआई कार्यक्रम की संरचना पर गौर करें।

बहस

तर्क (पैरामीटर) किसी प्रोग्राम को प्रदान की गई जानकारी की वस्तुएं हैं। इसे अक्सर स्थितीय तर्क के रूप में संदर्भित किया जाता है क्योंकि इन्हें उनकी स्थिति से पहचाना जाता है।

उदाहरण के लिए, जब हम project प्रॉपर्टी को कोर सेक्शन में सेट करना चाहते हैं, तो हम gcloud config set project <PROJECT_ID> चलाते हैं

विशेष रूप से, हम इसका अनुवाद कर सकते हैं

आदेश

कमांड तर्कों की एक श्रृंखला है जो कंप्यूटर को निर्देश प्रदान करती है।

पिछले उदाहरण के आधार पर, हमने gcloud config set project <PROJECT_ID> चलाकर project प्रॉपर्टी को कोर सेक्शन में सेट किया है

दूसरे शब्दों में, set एक कमांड है।

वैकल्पिक आदेश

आमतौर पर, आदेशों की आवश्यकता होती है लेकिन हम अपवाद बना सकते हैं। प्रोग्राम के उपयोग के मामले के आधार पर, हम वैकल्पिक कमांड को परिभाषित कर सकते हैं।

जैसा कि उनके आधिकारिक दस्तावेज़ में बताया गया है, gcloud config कमांड का संदर्भ लेते हुए, gcloud config एक कमांड समूह है जो आपको गुणों को संशोधित करने देता है। उपयोग इस प्रकार है:

 gcloud config GROUP | COMMAND [GCLOUD_WIDE_FLAG … ]

जिससे COMMAND या तो set जा सकता है, list जा सकती है, इत्यादि... (ध्यान दें कि GROUP config है)

विकल्प

विकल्प प्रलेखित प्रकार के पैरामीटर हैं जो किसी कमांड के व्यवहार को संशोधित करते हैं। वे कुंजी-मूल्य जोड़े हैं जिन्हें '-' या '--' द्वारा दर्शाया जाता है।

gcloud config कमांड समूह के उपयोग पर वापस लौटते हुए, इस मामले में विकल्प, GCLOUD_WIDE_FLAG है।

उदाहरण के लिए, मान लें कि हम कमांड का विस्तृत उपयोग और विवरण प्रदर्शित करना चाहते थे, हम gcloud config set –help चलाते हैं। दूसरे शब्दों में, --help विकल्प है।

एक अन्य उदाहरण यह है कि जब हम किसी विशिष्ट प्रोजेक्ट के कंप्यूट सेक्शन में ज़ोन प्रॉपर्टी सेट करना चाहते हैं, तो हम gcloud config set compute <ZONE_NAME> –project=<PROJECT_ID> चलाते हैं। दूसरे शब्दों में, --project एक विकल्प है जो <PROJECT_ID> मान रखता है।

यह भी ध्यान रखना महत्वपूर्ण है कि उनकी स्थिति आमतौर पर कोई मायने नहीं रखती।

अनिवार्य विकल्प

विकल्प, इसके नाम की तरह, आमतौर पर वैकल्पिक होते हैं, लेकिन इन्हें अनिवार्य बनाने के लिए भी तैयार किया जा सकता है।

उदाहरण के लिए, जब हम डेटाप्रोक क्लस्टर बनाना चाहते हैं, तो हम gcloud dataproc clusters create <CLUSTER_NAME> –region=<REGION> । और जैसा कि उनके उपयोग दस्तावेज़ में कहा गया है:

 gcloud dataproc clusters create (CLUSTER: –region=REGION)

--region ध्वज अनिवार्य है यदि इसे पहले कॉन्फ़िगर नहीं किया गया है।

छोटे विकल्प बनाम लंबे विकल्प

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

आपने रॉक चुना! अब कंप्यूटर इसका चयन करेगा.

इस ट्यूटोरियल के माध्यम से हम क्या हासिल करेंगे?

इसलिए मैंने झूठ बोला... हम स्टेपल रॉक-पेपर-कैंची सीएलआई कार्यक्रम को अपग्रेड करने का प्रयास नहीं करेंगे।

इसके बजाय, आइए वास्तविक दुनिया के परिदृश्य पर एक नज़र डालें:

रूपरेखा और लक्ष्य

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

उल्लिखित आवश्यकता के आधार पर, आइए इसकी आवश्यकताओं को परिभाषित करके अपने सीएलआई कार्यक्रम का मसौदा तैयार करें:

कार्यकारी आवश्यकताएं

• उपयोगकर्ता बोर्ड पर एक कॉलम में एक नया कार्ड जोड़ सकता है
  • आवश्यक इनपुट: कॉलम, कार्ड का नाम
  • वैकल्पिक इनपुट: कार्ड विवरण, कार्ड लेबल (मौजूदा में से चुनें)

गैर-कार्यात्मक आवश्यकताएँ

• उपयोगकर्ता को ट्रेलो खाते तक पहुंच प्रदान करने के लिए संकेत देने वाला कार्यक्रम (प्राधिकरण)
• उपयोगकर्ता को यह निर्धारित करने के लिए प्रेरित करने वाला प्रोग्राम कि किस ट्रेलो बोर्ड पर काम करना है (कॉन्फ़िगरेशन)

वैकल्पिक आवश्यकताएँ

• उपयोगकर्ता बोर्ड में एक नया कॉलम जोड़ सकता है
• उपयोगकर्ता बोर्ड में एक नया लेबल जोड़ सकता है
• उपयोगकर्ता सभी कॉलमों का सरलीकृत/विस्तृत दृश्य देख सकता है

उपरोक्त के आधार पर, हम अपने सीएलआई कार्यक्रम के आदेशों और विकल्पों को इस प्रकार औपचारिक रूप दे सकते हैं:

Ps अंतिम दो कॉलमों के बारे में चिंता न करें, हम इसके बारे में बाद में जानेंगे...

जहां तक हमारे तकनीकी स्टैक का सवाल है, हम इस पर कायम रहेंगे:

यूनिट परीक्षण

• pytest
• पाइटेस्ट-नकली
• सीएलआई-परीक्षण-सहायक

Trello

• पाइ-ट्रेलो (ट्रेलो एसडीके के लिए पायथन रैपर)

सीएलआई

• टाइपकर्ता
• अमीर
• सरल-अवधि-मेनू

उपयोगिताएँ (विविध)

• अजगर-dotenv

समय

हम इस परियोजना को भागों में निपटाएंगे और आप क्या उम्मीद कर सकते हैं इसका एक अंश यहां दिया गया है:

भाग ---- पहला

• py-trello बिजनेस लॉजिक का कार्यान्वयन

भाग 2

• सीएलआई व्यावसायिक तर्क का कार्यान्वयन
• सीएलआई कार्यक्रम को एक पैकेज के रूप में वितरित करना

भाग 3

• वैकल्पिक कार्यात्मक आवश्यकताओं का कार्यान्वयन
• पैकेज अद्यतन

कंप्यूटर ने चुनी कैंची! देखते हैं इस लड़ाई में कौन जीतता है...

आएँ शुरू करें

फ़ोल्डर संरचना

लक्ष्य सीएलआई प्रोग्राम को PyPI पर एक पैकेज के रूप में वितरित करना है। इस प्रकार, ऐसे सेटअप की आवश्यकता है:

 trellocli/ __init__.py __main__.py models.py cli.py trelloservice.py tests/ test_cli.py test_trelloservice.py README.md pyproject.toml .env .gitignore

यहां प्रत्येक फ़ाइल और/या निर्देशिका के बारे में गहराई से जानकारी दी गई है:

• trellocli : उपयोगकर्ताओं द्वारा उपयोग किए जाने वाले पैकेज नाम के रूप में कार्य करता है, उदाहरण के लिए, pip install trellocli
  • __init__.py : पैकेज के रूट का प्रतिनिधित्व करता है, फ़ोल्डर को पायथन पैकेज के रूप में अनुरूप बनाता है
  • __main__.py : प्रवेश बिंदु को परिभाषित करता है, और उपयोगकर्ताओं को -m ध्वज का उपयोग करके फ़ाइल पथ निर्दिष्ट किए बिना मॉड्यूल चलाने की अनुमति देता है, उदाहरण के लिए, python -m <module_name> को प्रतिस्थापित करने के लिए python -m <parent_folder>/<module_name>.py
  • models.py : विश्व स्तर पर उपयोग की जाने वाली कक्षाओं को संग्रहीत करता है, उदाहरण के लिए, ऐसे मॉडल जिनसे एपीआई प्रतिक्रियाओं के अनुरूप होने की उम्मीद की जाती है
  • cli.py : सीएलआई कमांड और विकल्पों के लिए व्यावसायिक तर्क संग्रहीत करता है
  • trelloservice.py : py-trello के साथ इंटरैक्ट करने के लिए व्यावसायिक तर्क संग्रहीत करता है
• tests : कार्यक्रम के लिए इकाई परीक्षण संग्रहीत करता है
  • test_cli.py : सीएलआई कार्यान्वयन के लिए इकाई परीक्षण संग्रहीत करता है
  • test_trelloservice.py : py-trello के साथ इंटरेक्शन के लिए यूनिट परीक्षणों को संग्रहीत करता है
• README.md : प्रोग्राम के लिए दस्तावेज़ संग्रहीत करता है
• pyproject.toml : पैकेज की कॉन्फ़िगरेशन और आवश्यकताओं को संग्रहीत करता है
• .env : पर्यावरण चर संग्रहीत करता है
• .gitignore : संस्करण नियंत्रण के दौरान अनदेखा की जाने वाली (ट्रैक नहीं की जाने वाली) फ़ाइलों को निर्दिष्ट करता है

पायथन पैकेजों को प्रकाशित करने की अधिक विस्तृत व्याख्या के लिए, यहां देखने के लिए एक बेहतरीन लेख है: पीईपीआई में एक ओपन-सोर्स पायथन पैकेज कैसे प्रकाशित करें, गीर अर्ने हेजेल द्वारा

स्थापित करना

आरंभ करने से पहले, आइए पैकेज की स्थापना के आधार पर बात करें।

हमारे पैकेज में __init__.py फ़ाइल से शुरुआत करें, जहां पैकेज स्थिरांक और चर संग्रहीत होते हैं, जैसे ऐप का नाम और संस्करण। हमारे मामले में, हम निम्नलिखित को आरंभ करना चाहते हैं:

• एप्लिकेशन का नाम
• संस्करण
• सफलता और त्रुटि स्थिरांक

 # trellocli/__init__.py __app_name__ = "trellocli" __version__ = "0.1.0" ( SUCCESS, TRELLO_WRITE_ERROR, TRELLO_READ_ERROR ) = range(3) ERRORS = { TRELLO_WRITE_ERROR: "Error when writing to Trello", TRELLO_READ_ERROR: "Error when reading from Trello" }

__main__.py फ़ाइल पर आगे बढ़ते हुए, आपके प्रोग्राम का मुख्य प्रवाह यहां संग्रहीत किया जाना चाहिए। हमारे मामले में, हम सीएलआई प्रोग्राम प्रविष्टि बिंदु को संग्रहीत करेंगे, यह मानते हुए कि cli.py में एक कॉल करने योग्य फ़ंक्शन होगा।

 # trellocli/__main__.py from trellocli import cli def main(): # we'll modify this later - after the implementation of `cli.py` pass if __name__ == "__main__": main()

अब जब पैकेज स्थापित हो गया है, तो आइए हमारी README.md फ़ाइल (मुख्य दस्तावेज़) को अपडेट करने पर एक नज़र डालें। ऐसी कोई विशिष्ट संरचना नहीं है जिसका हमें पालन करना चाहिए, लेकिन एक अच्छे README में निम्नलिखित शामिल होंगे:

• अवलोकन
• स्थापना और आवश्यकताएँ
• आरंभ करना और उपयोग

यदि आप गहराई से जानना चाहते हैं तो पढ़ने के लिए एक और बढ़िया पोस्ट: एक अच्छा रीडमी कैसे लिखें, मेरलोस द्वारा

यहां बताया गया है कि मैं इस प्रोजेक्ट के लिए README की संरचना कैसे करना चाहूंगा

 <!--- README.md --> # Overview # Getting Started # Usage # Architecture ## Data Flow ## Tech Stack # Running Tests # Next Steps # References

आइए अभी कंकाल को वैसे ही छोड़ दें - हम इस पर बाद में लौटेंगे।

आगे बढ़ते हुए, आइए आधिकारिक दस्तावेज़ीकरण के आधार पर अपने पैकेज के मेटाडेटा को कॉन्फ़िगर करें

 # pyproject.toml [project] name = "trellocli_<YOUR_USERNAME>" version = "0.1.0" authors = [ { name = "<YOUR_NAME>", email = "<YOUR_EMAIL>" } ] description = "Program to modify your Trello boards from your computer's command line" readme = "README.md" requires-python = ">=3.7" classifiers = [ "Programming Language :: Python :: 3", "License :: OSI Approved :: MIT License", "Operating System :: OS Independent", ] dependencies = [] [project.urls] "Homepage" = ""

ध्यान दें कि ऐसे प्लेसहोल्डर कैसे हैं जिन्हें आपको संशोधित करना है जैसे, आपका उपयोगकर्ता नाम, आपका नाम...

दूसरे नोट पर, हम अभी होमपेज यूआरएल को खाली छोड़ेंगे। GitHub पर इसे प्रकाशित करने के बाद हम इसमें बदलाव करेंगे। हम निर्भरता भाग को भी अभी खाली छोड़ देंगे, और जैसे-जैसे आगे बढ़ेंगे, जोड़ते जाएंगे।

सूची में अगली हमारी .env फ़ाइल होगी जहाँ हम अपने पर्यावरण चर जैसे एपीआई रहस्य और कुंजियाँ संग्रहीत करते हैं। यह ध्यान रखना महत्वपूर्ण है कि इस फ़ाइल को Git द्वारा ट्रैक नहीं किया जाना चाहिए क्योंकि इसमें संवेदनशील जानकारी है।

हमारे मामले में, हम यहां अपने ट्रेलो क्रेडेंशियल संग्रहीत करेंगे। ट्रेलो में पावर-अप बनाने के लिए, इस गाइड का पालन करें। अधिक विशेष रूप से, py-trello के उपयोग के आधार पर, जैसा कि हम अपने एप्लिकेशन के लिए OAuth का उपयोग करने का इरादा रखते हैं, हमें Trello के साथ बातचीत करने के लिए निम्नलिखित की आवश्यकता होगी:

• एपीआई कुंजी (हमारे आवेदन के लिए)
• एपीआई सीक्रेट (हमारे आवेदन के लिए)
• टोकन (उपयोगकर्ता का टोकन उनके डेटा तक पहुंच प्रदान करने के लिए)

एक बार जब आप अपनी एपीआई कुंजी और रहस्य पुनः प्राप्त कर लें, तो उन्हें .env फ़ाइल में संग्रहीत करें

 # .env TRELLO_API_KEY=<your_api_key> TRELLO_API_SECRET=<your_api_secret>

अंतिम लेकिन महत्वपूर्ण, आइए टेम्पलेट Python .gitignore का उपयोग करें जो यहां पाया जा सकता है। ध्यान दें कि यह सुनिश्चित करना महत्वपूर्ण है कि हमारी .env फ़ाइल को कभी भी ट्रैक न किया जाए - यदि किसी बिंदु पर, हमारी .env फ़ाइल को ट्रैक किया गया था, भले ही हमने बाद के चरणों में फ़ाइल को हटा दिया हो, क्षति हो चुकी है और दुर्भावनापूर्ण अभिनेता पिछले का पता लगा सकते हैं संवेदनशील जानकारी के लिए पैच.

अब जब सेटअप पूरा हो गया है, तो आइए अपने परिवर्तनों को GitHub पर आगे बढ़ाएं। pyproject.toml में निर्दिष्ट मेटाडेटा के आधार पर, अपने LICENSE और होमपेज URL को तदनुसार अपडेट करना याद रखें। बेहतर कमिट कैसे लिखें, इसके संदर्भ के लिए: विक्टोरिया डाई द्वारा बेहतर कमिट लिखें, बेहतर प्रोजेक्ट बनाएं

अन्य उल्लेखनीय कदम:

• प्रोजेक्ट के लिए वर्चुअलएन्व बनाएं

यूनिट परीक्षण

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

कार्यात्मक आवश्यकताओं के आधार पर, हमारी मुख्य चिंता उपयोगकर्ताओं को एक नया कार्ड जोड़ने की अनुमति देना है। py-trello में विधि का संदर्भ: add_card । ऐसा करने में सक्षम होने के लिए, हमें List वर्ग से add_card विधि को कॉल करना होगा, जिसे Board वर्ग से get_list फ़ंक्शन से पुनर्प्राप्त किया जा सकता है, जिसे पुनर्प्राप्त किया जा सकता है ...

आप सार समझ गए हैं - हमें अपने अंतिम गंतव्य तक पहुंचने के लिए कई सहायक तरीकों की आवश्यकता होगी, आइए इसे शब्दों में कहें:

• ग्राहक का टोकन पुनः प्राप्त करने के लिए परीक्षण करें
• बोर्ड पुनः प्राप्त करने के लिए परीक्षण करें
• बोर्ड पुनः प्राप्त करने के लिए परीक्षण करें
• बोर्ड से सूचियाँ पुनः प्राप्त करने के लिए परीक्षण करें
• किसी सूची को पुनः प्राप्त करने के लिए परीक्षण करें
• बोर्ड से लेबल पुनः प्राप्त करने के लिए परीक्षण करें
• किसी लेबल को पुनः प्राप्त करने के लिए परीक्षण करें
• कार्ड जोड़ने के लिए परीक्षण करें
• कार्ड में लेबल जोड़ने के लिए परीक्षण करें

यह ध्यान रखना भी महत्वपूर्ण है कि यूनिट परीक्षण लिखते समय, हम चाहते हैं कि हमारे परीक्षण यथासंभव व्यापक हों - क्या यह त्रुटियों को अच्छी तरह से संभालता है? क्या यह हमारे कार्यक्रम के हर पहलू को कवर करता है?

हालाँकि, इस ट्यूटोरियल के प्रयोजन के लिए, हम केवल सफलता के मामलों की जाँच करके चीजों को सरल बना देंगे।

कोड में गोता लगाने से पहले, आइए यूनिट परीक्षणों को लिखने/चलाने के लिए आवश्यक निर्भरताओं को शामिल करने के लिए अपनी pyproject.toml फ़ाइल को संशोधित करें।

 # pyproject.toml [project] dependencies = [ "pytest==7.4.0", "pytest-mock==3.11.1" ]

इसके बाद, आइए अपने वर्चुअलएन्व को सक्रिय करें और pip install . निर्भरताएँ स्थापित करने के लिए।

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

 # tests/test_trelloservice.py # module imports from trellocli import SUCCESS from trellocli.trelloservice import TrelloService from trellocli.models import * # dependencies imports # misc imports def test_get_access_token(mocker): """Test to check success retrieval of user's access token""" mock_res = GetOAuthTokenResponse( token="test", token_secret="test", status_code=SUCCESS ) mocker.patch( "trellocli.trelloservice.TrelloService.get_user_oauth_token", return_value=mock_res ) trellojob = TrelloService() res = trellojob.get_user_oauth_token() assert res.status_code == SUCCESS

मेरे नमूना कोड में ध्यान दें कि GetOAuthTokenResponse एक मॉडल है जिसे अभी models.py में सेट किया जाना है। यह क्लीनर कोड लिखने के लिए संरचना प्रदान करता है, हम इसे बाद में क्रिया में देखेंगे।

हमारे परीक्षण चलाने के लिए, बस python -m pytest चलाएँ। ध्यान दें कि हमारे परीक्षण कैसे विफल होंगे, लेकिन यह ठीक है - अंत में यह काम करेगा।

अभी के लिए, आइए अपनी trelloservice बनाएं। एक नई निर्भरता जोड़ने से शुरुआत करें, वह है py-trello रैपर।

 # pyproject.toml dependencies = [ "pytest==7.4.0", "pytest-mock==3.11.1", "py-trello==0.19.0" ]

एक बार फिर, pip install . निर्भरताएँ स्थापित करने के लिए।

मॉडल

अब, आइए अपने मॉडल बनाना शुरू करें - उन प्रतिक्रियाओं को विनियमित करने के लिए जिनकी हम trelloservice में अपेक्षा कर रहे हैं। इस भाग के लिए, हम जिस प्रकार के रिटर्न वैल्यू की उम्मीद कर सकते हैं उसे समझने के लिए हमारे यूनिट परीक्षणों और py-trello स्रोत कोड का संदर्भ लेना सबसे अच्छा है।

उदाहरण के लिए, मान लें कि हम उपयोगकर्ता के एक्सेस टोकन को पुनः प्राप्त करना चाहते हैं, py-trello के create_oauth_token फ़ंक्शन ( स्रोत कोड ) का संदर्भ लेते हुए, हम जानते हैं कि रिटर्न वैल्यू कुछ इस तरह होने की उम्मीद है

 # trellocli/models.py # module imports # dependencies imports # misc imports from typing import NamedTuple class GetOAuthTokenResponse(NamedTuple): token: str token_secret: str status_code: int

दूसरी ओर, परस्पर विरोधी नामकरण परंपराओं से सावधान रहें। उदाहरण के लिए, py-trello मॉड्यूल में List नाम का एक वर्ग है। इसके लिए एक समाधान यह होगा कि आयात के दौरान एक उपनाम प्रदान किया जाए।

 # trellocli/models.py # dependencies imports from trello import List as Trellolist

अपने कार्यक्रम की आवश्यकताओं के अनुरूप मॉडलों को तैयार करने के लिए इस अवसर का बेझिझक उपयोग करें। उदाहरण के लिए, मान लें कि आपको रिटर्न वैल्यू से केवल एक विशेषता की आवश्यकता है, तो आप अपने मॉडल को समग्र रूप से संग्रहीत करने के बजाय रिटर्न वैल्यू से उक्त मूल्य निकालने की अपेक्षा कर सकते हैं।

 # trellocli/models.py class GetBoardName(NamedTuple): """Model to store board id Attributes id (str): Extracted board id from Board value type """ id: str

व्यापार का तर्क

स्थापित करना

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

हमेशा की तरह, सभी आयात विवरण शीर्ष की ओर शामिल करें। फिर अपेक्षा के अनुरूप TrelloService वर्ग और प्लेसहोल्डर विधियाँ बनाएँ। विचार यह है कि हम cli.py में सेवा के एक साझा उदाहरण को आरंभ करेंगे और उसके अनुसार इसके तरीकों को कॉल करेंगे। इसके अलावा, हम स्केलेबिलिटी का लक्ष्य रख रहे हैं, इसलिए व्यापक कवरेज की आवश्यकता है।

 # trellocli/trelloservice.py # module imports from trellocli import TRELLO_READ_ERROR, TRELLO_WRITE_ERROR, SUCCESS from trellocli.models import * # dependencies imports from trello import TrelloClient # misc imports class TrelloService: """Class to implement the business logic needed to interact with Trello""" def __init__(self) -> None: pass def get_user_oauth_token() -> GetOAuthTokenResponse: pass def get_all_boards() -> GetAllBoardsResponse: pass def get_board() -> GetBoardResponse: pass def get_all_lists() -> GetAllListsResponse: pass def get_list() -> GetListResponse: pass def get_all_labels() -> GetAllLabelsResponse: pass def get_label() -> GetLabelResponse: pass def add_card() -> AddCardResponse: pass

कृपया ध्यान दें कि इस बार जब हम अपने परीक्षण चलाएंगे, तो हमारे परीक्षण कैसे उत्तीर्ण होंगे। वास्तव में, इससे हमें यह सुनिश्चित करने में मदद मिलेगी कि हम सही रास्ते पर बने रहें। वर्कफ़्लो हमारे कार्यों का विस्तार करने, हमारे परीक्षण चलाने, पास/असफल की जांच करने और तदनुसार रिफैक्टर करने के लिए होना चाहिए।

TrelloClient को अधिकृत करना और प्रारंभ करना

आइए __init__ फ़ंक्शन से प्रारंभ करें। यहां get_user_oauth_token फ़ंक्शन को कॉल करने और TrelloClient प्रारंभ करने का विचार है। फिर, ऐसी संवेदनशील जानकारी को केवल .env फ़ाइल में संग्रहीत करने की आवश्यकता पर जोर देते हुए, हम संवेदनशील जानकारी को पुनः प्राप्त करने के लिए python-dotenv निर्भरता का उपयोग करेंगे। अपनी pyproject.toml फ़ाइल को तदनुसार संशोधित करने के बाद, आइए प्राधिकरण चरणों को लागू करना शुरू करें।

 # trellocli/trelloservice.py class TrelloService: """Class to implement the business logic needed to interact with Trello""" def __init__(self) -> None: self.__load_oauth_token_env_var() self.__client = TrelloClient( api_key=os.getenv("TRELLO_API_KEY"), api_secret=os.getenv("TRELLO_API_SECRET"), token=os.getenv("TRELLO_OAUTH_TOKEN") ) def __load_oauth_token_env_var(self) -> None: """Private method to store user's oauth token as an environment variable""" load_dotenv() if not os.getenv("TRELLO_OAUTH_TOKEN"): res = self.get_user_oauth_token() if res.status_code == SUCCESS: dotenv_path = find_dotenv() set_key( dotenv_path=dotenv_path, key_to_set="TRELLO_OAUTH_TOKEN", value_to_set=res.token ) else: print("User denied access.") self.__load_oauth_token_env_var() def get_user_oauth_token(self) -> GetOAuthTokenResponse: """Helper method to retrieve user's oauth token Returns GetOAuthTokenResponse: user's oauth token """ try: res = create_oauth_token() return GetOAuthTokenResponse( token=res["oauth_token"], token_secret=res["oauth_token_secret"], status_code=SUCCESS ) except: return GetOAuthTokenResponse( token="", token_secret="", status_code=TRELLO_AUTHORIZATION_ERROR )

इस कार्यान्वयन में, हमने किसी भी संभावित त्रुटि को संभालने के लिए एक सहायक विधि बनाई, उदाहरण के लिए, जब उपयोगकर्ता प्राधिकरण के दौरान Deny पर क्लिक करता है। इसके अलावा, यह वैध प्रतिक्रिया वापस आने तक उपयोगकर्ता के प्राधिकरण के लिए बार-बार पूछने के लिए सेट किया गया है, क्योंकि तथ्य यह है कि हम तब तक जारी नहीं रख सकते जब तक कि उपयोगकर्ता हमारे ऐप को अपने खाते के डेटा तक पहुंचने के लिए अधिकृत नहीं करता है।

सहायक कार्य

अब जब प्राधिकरण भाग पूरा हो गया है, तो आइए सहायक कार्यों पर आगे बढ़ें, उपयोगकर्ता के ट्रेलो बोर्ड को पुनः प्राप्त करने से शुरू करें।

 # trellocli/trelloservice.py def get_all_boards(self) -> GetAllBoardsResponse: """Method to list all boards from user's account Returns GetAllBoardsResponse: array of user's trello boards """ try: res = self.__client.list_boards() return GetAllBoardsResponse( res=res, status_code=SUCCESS ) except: return GetAllBoardsResponse( res=[], status_code=TRELLO_READ_ERROR ) def get_board(self, board_id: str) -> GetBoardResponse: """Method to retrieve board Required Args board_id (str): board id Returns GetBoardResponse: trello board """ try: res = self.__client.get_board(board_id=board_id) return GetBoardResponse( res=res, status_code=SUCCESS ) except: return GetBoardResponse( res=None, status_code=TRELLO_READ_ERROR )

जहाँ तक सूचियों (कॉलम) को पुनः प्राप्त करने की बात है, हमें py-trello के Board वर्ग की जाँच करनी होगी, या दूसरे शब्दों में, हमें Board मान प्रकार के एक नए पैरामीटर को स्वीकार करना होगा।

 # trellocli/trelloservice.py def get_all_lists(self, board: Board) -> GetAllListsResponse: """Method to list all lists (columns) from the trello board Required Args board (Board): trello board Returns GetAllListsResponse: array of trello lists """ try: res = board.all_lists() return GetAllListsResponse( res=res, status_code=SUCCESS ) except: return GetAllListsResponse( res=[], status_code=TRELLO_READ_ERROR ) def get_list(self, board: Board, list_id: str) -> GetListResponse: """Method to retrieve list (column) from the trello board Required Args board (Board): trello board list_id (str): list id Returns GetListResponse: trello list """ try: res = board.get_list(list_id=list_id) return GetListResponse( res=res, status_code=SUCCESS ) except: return GetListResponse( res=None, status_code=TRELLO_READ_ERROR )

नया कार्ड जोड़ने का कार्य

अंतिम लेकिन महत्वपूर्ण बात यह है कि आखिरकार हम उस लक्ष्य तक पहुंच गए हैं जिसका हम पूरे समय से लक्ष्य रख रहे थे - एक नया कार्ड जोड़ना। ध्यान रखें कि हम यहां पहले घोषित सभी कार्यों का उपयोग नहीं करेंगे - सहायक कार्यों का लक्ष्य स्केलेबिलिटी बढ़ाना है।

 # trellocli/trelloservice.py def add_card( self, col: Trellolist, name: str, desc: str = "", labels: List[Label] = [] ) -> AddCardResponse: """Method to add a new card to a list (column) on the trello board Required Args col (Trellolist): trello list name (str): card name Optional Args desc (str): card description labels (List[Label]): list of labels to be added to the card Returns AddCardResponse: newly-added card """ try: # create new card new_card = col.add_card(name=name) # add optional description if desc: new_card.set_description(description=desc) # add optional labels if labels: for label in labels: new_card.add_label(label=label) return AddCardResponse( res=new_card, status_code=SUCCESS ) except: return AddCardResponse( res=new_card, status_code=TRELLO_WRITE_ERROR )

🎉 अब यह हो गया है और धूल-धूसरित हो गया है, तदनुसार अपने README को अपडेट करना याद रखें और अपने कोड को GitHub पर पुश करें।

बधाई हो! आप जीते। फिर से खेलें (y/N)?

लपेटें

मेरा साथ देने के लिए धन्यवाद:) इस ट्यूटोरियल के माध्यम से, आपने इकाई परीक्षण लिखते समय मॉकिंग को लागू करना, सामंजस्य के लिए संरचना मॉडल, मुख्य कार्यात्मकताओं को खोजने के लिए स्रोत कोड के माध्यम से पढ़ना और तीसरे पक्ष के रैपर का उपयोग करके व्यावसायिक तर्क को लागू करना सफलतापूर्वक सीखा।

भाग 2 पर नज़र रखें, जहां हम सीएलआई कार्यक्रम को लागू करने पर गहराई से विचार करेंगे।

इस बीच, आइए संपर्क में बने रहें 👀