एनोटेशन के लिए एक उपयोग मामला

मैं अभी घोषणा करना चाहता हूं कि यहां, एनोटेशन के तहत, हमारा मतलब डेकोरेटर नहीं है । और मुझे इस बात की जानकारी नहीं है कि सजावट करने वालों को कभी-कभी एनोटेशन कहा जाता है।



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



यहाँ PEP से एक विहित उदाहरण है:

def compile(source: "something compilable", filename: "where the compilable thing comes from", mode: "is this a single statement or a suite?"): ...
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

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

समस्या

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



यहाँ एक उदाहरण है:

 @app.route('/ugly_calc') def ugly_calc(): x, y = int(request.args['x']), int(request.args['y']) op = OPERATION[request.args['op']] #      . ,   —      (,   ) return str(op(x, y))
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

नियंत्रक में पहले से ही साफ, मान्य और सत्यापित तर्क प्राप्त करना अधिक तर्कसंगत होगा:

 @app.route('/calc') def calc(x:Arg(int), y:Arg(int), op:Arg(_from=OPERATION)): return str(op(x, y))
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

कोड पठनीयता और तर्क में हासिल कर लिया, और नियंत्रक का आकार परिचालन की वास्तविक संख्या तक कम हो गया।

अच्छी तरह से चलाई

सबसे पहले, हमें एक तर्क वर्ग को फेंकने की आवश्यकता है।



हम यहां से इसके लिए आधार लेंगे। बाहर फेंक दो जो हमें अब ज़रूरत नहीं है, और वोइला!

 class Arg(object): """ A request argument. """ def __init__(self, p_type=str, default=None): self.type = p_type self.default = default def _validate(self, value): """Perform conversion and validation on ``value``.""" return self.type(value) def validated(self, value): """ Convert and validate the given value according to the ``p_type`` Sets default if value is None """ if value is None: return self.default or self.type() return self._validate(value)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

हां, तर्क का वर्ग अभी के लिए बहुत न्यूनतर होगा। अंत में, हम किसी भी समय सभी प्रकार के आवश्यक और प्रेषित सत्यापनकर्ताओं के साथ इसका विस्तार करने में सक्षम होंगे।



अब हमें एक ऐसी चीज़ करने की ज़रूरत है जो "गंदे" तर्कों से शब्दकोश प्राप्त करेगी, और "स्वच्छ" लोगों को वापस कर देगी।



यह पता लगाने के लिए यहां उपयोगी होगा कि फ़ंक्शन को असाइन किए गए एनोटेशन एक ऐसा शब्दकोश __annotations__



जो __annotations__



विशेषता में __annotations__



।

 >>> def lol(yep, foo: "woof", bar: 32*2): pass >>> lol.__annotations__ {'foo': 'woof', 'bar': 64}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

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



फ़ंक्शन को इसका yep



नहीं मिलता है।



कुछ मैंने कथा से वापस कदम रखा। हम जारी रखते हैं:

 class Parser(object): def __call__(self, dct): """ Just for simplify """ return self.validated(dct) def __init__(self, structure): self.structure = structure def validated(self, dct): for key, arg_instatce in self.structure.items(): dct[key] = arg_instatce(dct.get(key, None)) return dct
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

यह वर्ग तीन रूबल की तरह सरल है। इसके उदाहरण प्रत्येक प्राप्त पैरामीटर को मान्य करते हैं, जिसका नाम प्राप्त शब्दकोश में और पैरामीटर संरचना में है, और फिर बदले हुए शब्दकोश को वापस लौटाएं। सामान्य तौर पर, इसे वापस करने का कोई मतलब नहीं है, यह सिर्फ एक आदत है :)



हम अतिरिक्त पैरामीटर __annotations__



और डेकोरेटर्स का उपयोग करते हुए काफी सक्रिय हैं। इसलिए, समस्याओं से बचने के लिए मानक wraps



को पूरक करना बेहतर होगा।

 from functools import wraps as orig_wraps, WRAPPER_ASSIGNMENTS WRAPPER_ASSIGNMENTS += ('__annotations__',) wraps = lambda x: orig_wraps(x, WRAPPER_ASSIGNMENTS)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

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

 class Endpoint(object): """              >>> plus = Endpoint(plus) >>> plus(5.0, "4") 9 """ def __call__(self, *args, **kwargs): return self.callable(*args, **kwargs) def __init__(self, func): self.__annotations__ = func.__annotations__ self.__name__ = func.__name__ self.set_func(func) def set_func(self, func): if func.__annotations__: #       self.parser = Parser(func.__annotations__) #     . #     ,  #   self.callable = self._wrap_callable(func) else: self.callable = func def _wrap_callable(self, func): @wraps(func) def wrapper(*args, **kwargs): #    ,  #   ,     . #   -       #     return func(*args, **self.parser(kwargs)) return wrapper
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

खैर, सब कुछ तैयार है। इस बात को फ्लास्क को पेंच करने का समय है।

वैसे, इस बिंदु पर हमने जो कुछ भी देखा, वह समान रूप से पर्याप्त है ताकि अन्य रूपरेखाओं में समान कोड टुकड़े का उपयोग किया जा सके। और फ्रेमवर्क के बिना भी :)



चलिए शुरू करते हैं:

 class Flask(OrigFlask): #   .    froute = OrigFlask.route def route(self, rule, **options): """     . """ def registrator(func): #    : 1  - 1 . if 'methods' in options: method = options['methods'][0] else: method = 'GET' wrapped = self.register_endpoint(rule, func, options.get('name'), method) return wrapped return registrator def register_endpoint(self, rule, func, endpoint_name=None, method='GET'): endpoint_name = endpoint_name or func.__name__ endpoint = Endpoint(func) wrapped = self._arg_taker(endpoint) self.add_url_rule(rule, "%s.%s" % (endpoint_name, method), wrapped, methods=[method]) return wrapped def _arg_taker(self, func): """       .  . """ @wraps(func) def wrapper(*args, **kwargs): for key_name in func.__annotations__.keys(): kwargs[key_name] = request.args.get(key_name) return func(*args, **kwargs) return wrapper
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

महान, बुनियादी कार्यक्षमता काम करती है। अब तक _from के बिना, लेकिन, मुझे लगता है, अब आप इसके बिना कर सकते हैं।



शलजम



आप अपने प्रश्न पूछ सकते हैं और विभिन्न प्रकार की सुविधाएँ प्रदान कर सकते हैं जो खराब हो सकती हैं।

युपीडी

इस गर्भनिरोधक के उपयोग पर एक छोटी पुस्तिका लिखी।