डेकोरेटर में बवंडर या पैच बाइटकोड में अतुल्यकालिक कॉल का सबसे छोटा रिकॉर्ड

बवंडर में जटिल अतुल्यकालिक हैंडलर कभी-कभी दर्जनों कॉलबैक फ़ंक्शंस में फैल जाता है, जिससे कोड को समझना और संशोधित करना मुश्किल हो जाता है। इसलिए, एक टोरनेडो.जन मॉड्यूल है जो आपको एक हैंडलर को जनरेटर के रूप में लिखने की अनुमति देता है। लेकिन उपज का एक बहुत gen.Task (...) बहुत अच्छा नहीं दिखता है। इसलिए, प्रलाप के एक फिट में, मैंने एक डेकोरेटर लिखा जो लिखने को सरल बनाता है:

को	के बाद
@asynchronous @gen.engine def get(self): result, status = yield gen.Task( db.users.find_one, { '_id': ObjectId(user_id), }, )	@asynchronous @gen.engine @shortgen def get(self): result, status << db.users.find_one_e({ '_id': ObjectId(user_id), }, )

यह कैसे काम करता है

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

from byteplay import Code from pprint import pprint def gen(): a = yield 1 pprint(Code.from_code(gen.func_code).code)	[(SetLineno, 5), # 5 (LOAD_CONST, 1), # 1 (YIELD_VALUE, None), # "" (STORE_FAST, 'a'), # a (LOAD_CONST, None), (RETURN_VALUE, None)]
def shift(): a << 1 pprint(Code.from_code(shift.func_code).code)	[(SetLineno, 10), (LOAD_GLOBAL, 'a'), # a (LOAD_CONST, 1), # 1 (BINARY_LSHIFT, None), # a (POP_TOP, None), # (LOAD_CONST, None), (RETURN_VALUE, None)]

इसलिए, हम इस स्थिति के लिए विशुद्ध रूप से एक साधारण पैच बनाएंगे:

from byteplay import YIELD_VALUE, STORE_FAST code = Code.from_code(shift.func_code) code.code[3] = (YIELD_VALUE, None) code.code[4] = (STORE_FAST, 'a') code.code.pop(1) pprint(code.code)

[(SetLineno, 10), (LOAD_CONST, 1), (YIELD_VALUE, None), (STORE_FAST, 'a'), (LOAD_CONST, None), (RETURN_VALUE, None)]

अब हमारे पास जीन फ़ंक्शन के बायटेकोड के समान बाईटेकोड है, परिणाम को शिफ्ट करने और जांचने के लिए इसे लागू करें:

shift.func_code = code.to_code() res_gen = gen().send(None) res_shift = shift().send(None) print res_gen print res_shift print res_gen == res_shift

1 1 True

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

 def fetch(callback): callback(1) class Handler(BaseHandler): @asynchronous @gen.engine @shortgen def get(self): result << gen.Task(fetch) 

कोड थोड़ा बेहतर हो गया है, लेकिन हमें अभी भी कॉल को मैन्युअल रूप से gen.Task में लपेटना है , इसलिए हम इस प्रक्रिया को स्वचालित करने के लिए एक और डेकोरेटर बनाएंगे:

 def fastgen(fnc): return partial(gen.Task, fnc) @fastgen def fetch(callback): callback(1) class Handler(BaseHandler): @asynchronous @gen.engine @shortgen def get(self): result << fetch() 

अब सब कुछ बहुत अच्छा लग रहा है, लेकिन यह तीसरे पक्ष के पुस्तकालयों के साथ कैसे काम करेगा? लेकिन कुछ भी नहीं, इसलिए अब हमें उन्हें पैच करने की आवश्यकता है! नहीं, हमने अभी बायटेककोड पैच नहीं किया है, लेकिन हम सिर्फ बंदर पैच का उपयोग करेंगे। पुराने कोड को न तोड़ने के लिए, हम आवश्यक वर्गों के लिए __getattribute__ को प्रतिस्थापित करेंगे:

 def getattribute(self, name): attr = None if name.find('_e') == len(name) - 2: attr = getattr(self, name[:-2]) if hasattr(attr, '__call__'): return fastgen(attr) else: return super(self.__class__, self).__getattribute__(name) 

अब यदि पैच की गई ऑब्जेक्ट में कोई विशेषता नहीं है, उदाहरण के लिए, find_e ( पोस्टफ़िक्स _e को जोड़ा गया था ताकि पुराने कोड को न तोड़ा जाए), हम फास्टटैगन डेकोरेटर में लिपटे हुए खोज विशेषता को वापस कर देंगे।
और अब कोड, उदाहरण के लिए, asyncmongo के लिए, इस तरह दिखेगा:

 from asyncmongo.cursor import Cursor Cursor.__getattribute__ = getattribute class Handler(BaseHandler): @asynchronous @gen.engine @shortgen def get(self): result, status << self.db.posts.find_e({'name': 'post'}) 

इसका उपयोग कैसे करें

सबसे पहले, परिणामस्वरूप मॉड्यूल स्थापित करें:

 pip install -e git+https://github.com/nvbn/evilshortgen.git#egg=evilshortgen 

अब उन वर्गों को पैच करें जिनकी हमें आवश्यकता है:

 from evilshortgen import shortpatch shortpatch(Cls1, Cls2, Cls3) 

डेकोरेटर में अपने स्वयं के अतुल्यकालिक तरीकों और कार्यों को लपेटें:

 from evilshortgen import fastgen @fastgen def fetch(id, callback): return callback(id) 

और हैंडलर का उपयोग करें:

 from evilshortgen import shortgen class Handler(BaseHandler): @asynchronous @gen.engine @shortgen def get(self, id): data << fetch(12) num, user << Cls1.fetch() 

ज्ञात मुद्दे

एक कॉल केवल चर के लिए मान सेट कर सकती है:

 a << fetch() #  self.a << fetch() #   

जटिल decompressions समर्थित नहीं हैं:

 a, b << fetch() #  (a, b), c << fetch() #   

संदर्भ

गितूब पर एविलशॉर्टजेन
बाइटकोड के बारे में विस्तार से
Byteplay