ग्राफीन-पायथन के साथ रोमांच का वर्ष

हाय सब, मैं एक अजगर डेवलपर हूँ। पिछले साल मैंने ग्राफीन-पाइथन + डीजेंगो ओआरएम के साथ काम किया और इस दौरान मैंने ग्राफीन के साथ काम करने के लिए कुछ प्रकार के उपकरण बनाने की कोशिश की। नतीजतन, मुझे एक छोटा सा graphene-framework कोड आधार और कुछ नियमों का एक सेट मिला, जिसे मैं साझा करना चाहूंगा।

ग्राफीन-पायथन क्या है?

ग्राफीन-python.org के अनुसार, तब:

ग्राफीन-पायथन आसानी से पायथन का उपयोग करके ग्राफकॉल एपीआई बनाने के लिए एक पुस्तकालय है। इसका मुख्य कार्य एक सरल लेकिन एक ही समय में एक्स्टेंसिबल एपीआई प्रदान करना है जो प्रोग्रामर्स के जीवन को आसान बनाता है।

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

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

वैसे भी, मैंने इसे परियोजना में उपयोग करने का निर्णय लिया और कई समस्याओं में भाग लिया, सौभाग्य से, उनमें से अधिकांश को हल कर दिया (ग्रेफीन की समृद्ध अनैच्छिक सुविधाओं के लिए धन्यवाद)। मेरे कुछ समाधान विशुद्ध रूप से वास्तुशिल्प हैं और मेरी रूपरेखा के बिना, बॉक्स से बाहर उपयोग किए जा सकते हैं। हालांकि, उनमें से बाकी को अभी भी कुछ कोड बेस की आवश्यकता है।

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

इस लेख का उद्देश्य किसी भी सार्थक प्रतिक्रिया को प्राप्त करना है, इसलिए मैं टिप्पणियों में आलोचना की प्रतीक्षा करूंगा!

नोट: लेख को पढ़ना जारी रखने से पहले, मैं दृढ़ता से अनुशंसा करता हूं कि आप अपने आप को परिचित करें कि ग्राफकॉक क्या है।

म्यूटेशन

ग्राफ़कॉल के बारे में अधिकांश चर्चाएँ डेटा प्राप्त करने पर केंद्रित होती हैं, लेकिन किसी भी स्वाभिमानी प्लेटफ़ॉर्म को सर्वर पर संग्रहीत डेटा को संशोधित करने के लिए एक तरीके की आवश्यकता होती है।

म्यूटेशन के साथ शुरू करते हैं।

निम्नलिखित कोड पर विचार करें:

 class UpdatePostMutation(graphene.Mutation): class Arguments: post_id = graphene.ID(required=True) title = graphene.String(required=True) content = graphene.String(required=True) image_urls = graphene.List(graphene.String, required=False) allow_comments = graphene.Boolean(required=True) contact_email = graphene.String(required=True) ok = graphene.Boolean(required=True) errors = graphene.List(graphene.String, required=True) def mutate(_, info, post_id, title, content, image_urls, allow_comments, contact_email): errors = [] try: post = get_post_by_id(post_id) except PostNotFound: return UpdatePostMutation(ok=False, errors=['post_not_found']) if not info.context.user.is_authenticated: errors.append('not_authenticated') if len(title) < TITLE_MIN_LENGTH: errors.append('title_too_short') if not is_email(contact_email): errors.append('contact_email_not_valid') if post.owner != info.context.user: errors.append('not_post_owner') if Post.objects.filter(title=title).exists(): errors.append('title_already_taken') if not errors: post = Utils.update_post(post, title, content, image_urls, allow_comments, contact_email) return UpdatePostMutation(ok=bool(errors), errors=errors) 

UpdatePostMutation किए गए डेटा का उपयोग करके पोस्ट को बदल देता है और कुछ शर्तों के पूरा न होने पर त्रुटियों को वापस करता है।

केवल इस कोड को देखने की आवश्यकता है, क्योंकि यह इसकी गैर-व्यापकता और असमर्थता के कारण दिखाई देता है:

1. mutate फ़ंक्शन के बहुत सारे तर्क, जिनकी संख्या बढ़ सकती है, भले ही हम संपादित करने के लिए अधिक फ़ील्ड जोड़ना चाहते हों।
2. क्लाइंट पक्ष पर समान दिखने के लिए म्यूटेशन के लिए, उन्हें errors और ok लौटना चाहिए, ताकि उनकी स्थिति और यह समझना हमेशा संभव हो सके।
3. mutate फ़ंक्शन में किसी ऑब्जेक्ट को खोजें और पुनर्प्राप्त करें। म्यूटेशन फ़ंक्शन उपवास के साथ संचालित होता है, और यदि यह नहीं है, तो उत्परिवर्तन नहीं होना चाहिए।
4. एक म्यूटेशन में अनुमतियों की जाँच करना। यदि उपयोगकर्ता को ऐसा करने का अधिकार नहीं है (कुछ पोस्ट को संपादित करें) उत्परिवर्तन नहीं होना चाहिए।
5. एक बेकार पहला तर्क (एक जड़ जो हमेशा शीर्ष स्तर के क्षेत्रों के लिए None , जो कि हमारा उत्परिवर्तन है)।
6. त्रुटियों का एक अप्रत्याशित सेट: यदि आपके पास स्रोत कोड या प्रलेखन नहीं है, तो आपको नहीं पता होगा कि यह परिवर्तन क्या त्रुटियों को वापस कर सकते हैं, क्योंकि वे योजना में प्रतिबिंबित नहीं होते हैं।
7. कई टेम्प्लेट त्रुटि जांच हैं जो सीधे mutate पद्धति में किए जाते हैं, जिसमें विभिन्न प्रकार के चेक के बजाय डेटा को mutate शामिल है। आदर्श mutate में एक पंक्ति शामिल होनी चाहिए - पोस्ट संपादन फ़ंक्शन के लिए एक कॉल।

संक्षेप में, वस्तुओं को एक्सेस करने और इनपुट को मान्य करने जैसे तृतीय-पक्ष कार्यों का ध्यान रखने के बजाय, mutate को डेटा को संशोधित करना चाहिए । हमारा लक्ष्य कुछ इस तरह से है:

  def mutate(post, info, input): post = Utils.update_post(post, **input) return UpdatePostMutation(post=post) 

अब ऊपर के बिंदुओं पर गौर करते हैं।

कस्टम प्रकार

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

 class Email(graphene.String): # ... 

यह स्पष्ट लग सकता है, लेकिन ध्यान देने योग्य है।

इनपुट प्रकार

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

 class UpdatePostInput(graphene.InputObjectType): title = graphene.String(required=True) content = graphene.String(required=True) image_urls = graphene.List(graphene.String, required=False) allow_comments = graphene.Boolean(required=True) contact_email = graphene.String(required=True) 

करने के लिए:

 mutation( $post_id: ID!, $title: String!, $content: String!, $image_urls: String!, $allow_comments: Boolean!, $contact_email: Email! ) { updatePost( post_id: $post_id, title: $title, content: $content, image_urls: $image_urls, allow_comments: $allow_comments, contact_email: $contact_email, ) { ok } } 

के बाद:

 mutation($id: ID!, $input: UpdatePostInput!) { updatePost(id: $id, input: $input) { ok } } 

म्यूटेशन कोड में परिवर्तन होता है:

 class UpdatePostMutation(graphene.Mutation): class Arguments: input = UpdatePostInput(required=True) id = graphene.ID(required=True) ok = graphene.Boolean(required=True) errors = graphene.List(graphene.String, required=True) def mutate(_, info, input, id): # ... if not errors: post = Utils.update_post(post, **input.__dict__) return UpdatePostMutation(errors=errors) 

आधार उत्परिवर्तन वर्ग

जैसा कि पैराग्राफ 2 में उल्लेख किया गया है, म्यूटेशन में errors और ok होना चाहिए ताकि उनकी स्थिति और क्या कारण हो, इसे हमेशा समझा जा सके । यह काफी सरल है, हम एक बेस क्लास बनाते हैं:

 class MutationPayload(graphene.ObjectType): ok = graphene.Boolean(required=True) errors = graphene.List(graphene.String, required=True) query = graphene.Field('main.schema.Query', required=True) def resolve_ok(self, info): return len(self.errors or []) == 0 def resolve_errors(self, info): return self.errors or [] def resolve_query(self, info): return {} 

कुछ नोट:

• resolve_ok विधि resolve_ok , इसलिए हमें स्वयं ok गणना करने की आवश्यकता नहीं है।
• query फ़ील्ड रूट Query , जो आपको म्यूटेशन अनुरोध के अंदर सीधे डेटा क्वेरी करने की अनुमति देता है (म्यूटेशन पूरा होने के बाद डेटा का अनुरोध किया जाएगा)।
  

   mutation($id: ID!, $input: PostUpdateInput!) { updatePost(id: $id, input: $input) { ok query { profile { totalPosts } } } } 

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

बेस म्यूटेशन क्लास के साथ, कोड में बदल जाता है:

 class UpdatePostMutation(MutationPayload, graphene.Mutation): class Arguments: input = UpdatePostInput(required=True) id = graphene.ID(required=True) def mutate(_, info, input, id): # ... 

रूट म्यूटेशन

हमारा म्यूटेशन अनुरोध अब इस तरह दिखता है:

 mutation($id: ID!, $input: PostUpdateInput!) { updatePost(id: $id, input: $input) { ok } } 

एक वैश्विक दायरे में सभी म्यूटेशन को शामिल करना अच्छा अभ्यास नहीं है। यहाँ कुछ कारण हैं:

1. म्यूटेशन की बढ़ती संख्या के साथ, आपके लिए आवश्यक म्यूटेशन को ढूंढना अधिक से अधिक कठिन हो जाता है।
2. एक नाम स्थान के कारण, म्यूटेशन के नाम पर "इसके मॉड्यूल का नाम" शामिल करना आवश्यक है, उदाहरण के लिए update Post ।
3. आपको म्यूटेशन के तर्क के रूप में id पास करना होगा।

मैं रूट म्यूटेशन का उपयोग करने का सुझाव देता हूं। उनका लक्ष्य म्यूटेशन को अलग-अलग स्कोप में बदलकर और म्यूटेशन को ऑब्जेक्ट्स के एक्सेस से तर्क से मुक्त करना और उन तक अधिकारों को एक्सेस करना है।

नया अनुरोध इस तरह दिखता है:

 mutation($id: ID!, $input: PostUpdateInput!) { post(id: $id) { update(input: $input) { ok } } } 

अनुरोध तर्क समान रहते हैं। अब परिवर्तन फ़ंक्शन को post अंदर "कॉल" किया जाता है, जो निम्नलिखित तर्क को लागू करने की अनुमति देता है:

1. यदि id post करने के लिए पारित नहीं की जाती है, तो यह {} वापस आ जाती है यह आपको भीतर म्यूटेशन जारी रखने की अनुमति देता है। उन म्यूटेशनों के लिए उपयोग किया जाता है जिन्हें रूट तत्व की आवश्यकता नहीं होती है (उदाहरण के लिए, ऑब्जेक्ट बनाने के लिए)।
2. यदि id पारित हो जाता है, तो संबंधित तत्व पुनर्प्राप्त किया जाता है।
3. यदि ऑब्जेक्ट नहीं मिला है, तो None वापस None , और यह अनुरोध पूरा करता है, म्यूटेशन नहीं कहा जाता है।
4. यदि ऑब्जेक्ट पाया जाता है, तो उसे हेरफेर करने के लिए उपयोगकर्ता के अधिकारों की जांच करें।
5. यदि उपयोगकर्ता के पास अधिकार नहीं हैं, तो None लौटाया जाता है और अनुरोध पूरा हो जाता है, म्यूटेशन नहीं कहा जाता है।
6. यदि उपयोगकर्ता के अधिकार हैं, तो पाया गया ऑब्जेक्ट वापस आ गया है और म्यूटेशन इसे रूट के रूप में प्राप्त करता है - पहला तर्क।

इस प्रकार, उत्परिवर्तन कोड में परिवर्तन होता है:

 class UpdatePostMutation(MutationPayload, graphene.Mutation): class Arguments: input = UpdatePostInput() def mutate(post, info, input): if post is None: return None errors = [] if not info.context.user.is_authenticated: errors.append('not_authenticated') if len(title) < TITLE_MIN_LENGTH: errors.append('title_too_short') if Post.objects.filter(title=title).exists(): errors.append('title_already_taken') if not errors: post = Utils.update_post(post, **input.__dict__) return UpdatePostMutation(errors=errors) 

• म्यूटेशन की जड़ - पहला तर्क - अब टाइप Post का एक ऑब्जेक्ट है, जिसके ऊपर म्यूटेशन किया जाता है।
• प्राधिकरण चेक रूट म्यूटेशन कोड में चला गया।

रूट म्यूटेशन कोड:

 class PostMutationRoot(MutationRoot): class Meta: model = Post has_permission = lambda post, user: post.owner == user update = UpdatePostMutation.Field() 

त्रुटि इंटरफ़ेस

अनुमानित त्रुटियों का एक सेट बनाने के लिए, उन्हें डिज़ाइन में परिलक्षित होना चाहिए।

• चूंकि म्यूटेशन कई त्रुटियों को वापस कर सकता है, इसलिए त्रुटियों की एक सूची होनी चाहिए।
• चूंकि त्रुटियों को विभिन्न प्रकारों द्वारा दर्शाया जाता है, इसलिए विशिष्ट उत्परिवर्तन के लिए विशिष्ट Union त्रुटियों का अस्तित्व होना चाहिए।
• त्रुटियों को एक-दूसरे के समान बने रहने के लिए, उन्हें इंटरफ़ेस लागू करना होगा, आइए इसे ErrorInterface कहते हैं। इसे दो फ़ील्ड्स दें: ok और message ।

इस प्रकार, त्रुटियाँ टाइप [SomeMutationErrorsUnion]! होनी चाहिए [SomeMutationErrorsUnion]! । SomeMutationErrorsUnion सभी उपप्रकारों को SomeMutationErrorsUnion को लागू करना चाहिए।

हमें मिलता है:

 class NotAuthenticated(graphene.ObjectType): message = graphene.String(required=True, default_value='not_authenticated') class Meta: interfaces = [ErrorInterface, ] class TitleTooShort(graphene.ObjectType): message = graphene.String(required=True, default_value='title_too_short') class Meta: interfaces = [ErrorInterface, ] class TitleAlreadyTaken(graphene.ObjectType): message = graphene.String(required=True, default_value='title_already_taken') class Meta: interfaces = [ErrorInterface, ] class UpdatePostMutationErrors(graphene.Union): class Meta: types = [NotAuthenticated, TitleIsTooShort, TitleAlreadyTaken, ] 

यह अच्छा लग रहा है, लेकिन बहुत अधिक कोड है। हम इन त्रुटियों को मक्खी पर उत्पन्न करने के लिए मेटाक्लस का उपयोग करते हैं:

 class PostErrors(metaclass=ErrorMetaclass): errors = [ 'not_authenticated', 'title_too_short', 'title_already_taken', ] class UpdatePostMutationErrors(graphene.Union): class Meta: types = [PostErrors.not_authenticated, PostErrors.title_too_short, PostErrors.title_already_taken, ] 

म्यूटेशन में लौटी त्रुटियों की घोषणा जोड़ें:

 class UpdatePostMutation(MutationPayload, graphene.Mutation): class Arguments: input = UpdatePostInput() errors = graphene.List(UpdatePostMutationErrors, required=True) def mutate(post, info, input): # ... 

त्रुटियों के लिए जाँच करें

यह मुझे लगता है कि mutate पद्धति को डेटा को म्यूट करने के अलावा किसी भी चीज़ की परवाह नहीं करनी चाहिए। इसे प्राप्त करने के लिए, आपको इस फ़ंक्शन के लिए उनके कोड में त्रुटियों की जांच करने की आवश्यकता है।

कार्यान्वयन को स्वीकार करते हुए, यहाँ परिणाम है:

 class UpdatePostMutation(DefaultMutation): class Arguments: input = UpdatePostInput() class Meta: root_required = True authentication_required = True #   ,    True   # An iterable of tuples (error_class, checker) checks = [ ( PostErrors.title_too_short, lambda post, input: len(input.title) < TITLE_MIN_LENGTH ), ( PostErrors.title_already_taken, lambda post, input: Post.objects.filter(title=input.title).exists() ), ] def mutate(post, info, input): post = Utils.update_post(post, **input.__dict__) return UpdatePostMutation() 

mutate फ़ंक्शन शुरू करने से पहले, प्रत्येक चेकर ( checks सरणी के सदस्यों का दूसरा तत्व) कहा जाता है। यदि True लौटाया जाता है, तो संबंधित त्रुटि पाई जाती है। यदि कोई त्रुटि नहीं मिलती है, तो mutate फ़ंक्शन को कहा जाता है।

मैं समझाऊंगा:

• चेक फ़ंक्शंस, mutate फ़ंक्शंस की तरह ही तर्क देते हैं।
• यदि कोई त्रुटि मिलती है, तो सत्यापन कार्य True होना चाहिए।
• प्राधिकरण के चेक और रूट तत्व की उपस्थिति काफी सामान्य है और Meta फ्लैग में सूचीबद्ध हैं।
• True authentication_required प्राधिकरण जाँच जोड़ता है।
• root_required " root is not None " चेक जोड़ता है।
• UpdatePostMutationErrors अब आवश्यकता नहीं है। checks सरणी के त्रुटि वर्गों के आधार पर फ्लाई पर संभावित त्रुटियों का एक संघ बनाया जाता है।

जेनरिक

अंतिम अनुभाग में उपयोग किए गए DefaultMutation में एक pre_mutate विधि pre_mutate है, जो आपको त्रुटियों की जाँच करने से पहले इनपुट तर्कों को बदलने की अनुमति देता है, और तदनुसार, उत्परिवर्तन को लागू करता है।

एक सामान्य स्टार्टर किट भी है जो कोड को छोटा बनाता है और जीवन को आसान बनाता है।
नोट: वर्तमान में जेनेरिक कोड django ORM के लिए विशिष्ट है

CreateMutation

model या create_function एक की आवश्यकता है। डिफ़ॉल्ट रूप से, create_function इस तरह दिखता है:

 model._default_manager.create(**data, owner=user) 

यह असुरक्षित लग सकता है, लेकिन यह मत भूलो कि ग्रेफेल में अंतर्निहित प्रकार की जाँच है, साथ ही म्यूटेशन में चेक भी है।

यह एक post_mutate विधि भी प्रदान करता है जिसे तर्कों के साथ post_mutate बाद कहा जाता है ( post_mutate (instance_created, user) , जिसके परिणाम को क्लाइंट को वापस कर दिया जाएगा।

UpdateMutation

आपको update_function सेट करने देता है। डिफ़ॉल्ट रूप से:

 def default_update_function(instance, user=None, **data): instance.__dict__.update(data) instance.save() return instance 

root_required डिफ़ॉल्ट रूप से True है।

यह एक post_mutate विधि भी प्रदान करता है जिसे update_function बाद तर्कों (instance_updated, user) update_function (instance_updated, user) साथ कहा जाता है, जिसके परिणामस्वरूप क्लाइंट को वापस कर दिया जाएगा।

और यही हमें चाहिए!

अंतिम कोड:

 class UpdatePostMutation(UpdateMutation): class Arguments: input = UpdatePostInput() class Meta: checks = [ ( PostErrors.title_too_short, lambda post, input: len(input.title) < TITLE_MIN_LENGTH ), ( PostErrors.title_already_taken, lambda post, input: Post.objects.filter(title=input.title).exists() ), ] 

DeleteMutation

आपको delete_function सेट करने देता है। डिफ़ॉल्ट रूप से:

 def default_delete_function(instance, user=None, **data): instance.delete() 

निष्कर्ष

यह लेख केवल एक पहलू पर विचार करता है, हालांकि मेरी राय में यह सबसे जटिल है। मेरे पास रिज़ॉल्वर और प्रकार के साथ-साथ ग्राफीन-पायथन में सामान्य चीजें हैं।

मेरे लिए खुद को एक अनुभवी डेवलपर कहना मुश्किल है, इसलिए मुझे किसी भी प्रतिक्रिया के साथ-साथ सुझाव भी बहुत पसंद आएंगे।

स्रोत कोड यहां पाया जा सकता है ।