स्टैक पर स्टोर की स्थिति

सब कुछ नया पुराना भूल गया है!

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

यदि आप कई बॉट्स का कोड देखते हैं, तो यह आमतौर पर उसी पैटर्न पर आता है:

• संदेश आता है
• यह उपयोगकर्ता संदेश हैंडलर ( callback ) को दिया जाता है

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

आइए इसे जानने की कोशिश करें।

मैं अस्वीकरण के साथ शुरू करूँगा:

1. इस आलेख में जो वर्णित किया गया है वह बॉट के प्रकारों के लिए उपयुक्त है <-> ।
2. इस लेख का कोड एक स्केच कोड है। इस लेख के लिए विशेष रूप से 15 मिनट में लिखा। इसलिए कड़ाई से न्याय न करें।
3. मैंने व्यवसाय में एक समान दृष्टिकोण का उपयोग किया: लोड संतुलन के साथ। लेकिन, अफसोस, मेरे उत्पादन कोड में बहुत अधिक बुनियादी निर्भरता है और इसे प्रकाशित करना आसान नहीं है। इसलिए, लेख में इस स्केच का उपयोग किया जाता है। मैं प्रतिमान विकास के मुद्दों पर संपर्क करूंगा (मैं यह वर्णन करूंगा कि हम कहां और कैसे विकसित हुए हैं)।

अच्छा, अब चलो।

समर्थन के रूप में, aiogram अतुल्यकालिक पुस्तकालय , python3.7 + पर विचार करें। लिंक में एक साधारण इको बॉट का उदाहरण है।

मैं इसे यहां कॉपी करूंगा:

 """ This is a echo bot. It echoes any incoming text messages. """ import logging from aiogram import Bot, Dispatcher, executor, types API_TOKEN = 'BOT TOKEN HERE' # Configure logging logging.basicConfig(level=logging.INFO) # Initialize bot and dispatcher bot = Bot(token=API_TOKEN) dp = Dispatcher(bot) @dp.message_handler(regexp='(^cat[s]?$|puss)') async def cats(message: types.Message): with open('data/cats.jpg', 'rb') as photo: ''' # Old fashioned way: await bot.send_photo( message.chat.id, photo, caption='Cats are here ', reply_to_message_id=message.message_id, ) ''' await message.reply_photo(photo, caption='Cats are here ') @dp.message_handler() async def echo(message: types.Message): # old style: # await bot.send_message(message.chat.id, message.text) await message.answer(message.text) if __name__ == '__main__': executor.start_polling(dp, skip_updates=True) 

हम देखते हैं कि बॉट का संगठन पारंपरिक है। जब भी कोई उपयोगकर्ता हमारे लिए कुछ लिखता है, एक हैंडलर फ़ंक्शन कहलाता है।

क्या गलत है इस प्रतिमान के साथ?

जटिल संवादों को लागू करने के लिए हैंडलर का कार्य अपने प्रत्येक कॉल पर कुछ प्रकार के भंडारण से अपने राज्य को पुनर्स्थापित करना होगा।

यदि आप अधिकांश बॉट्स को देखते हैं जो किसी प्रकार के व्यवसाय का समर्थन करते हैं (उदाहरण के लिए, काम पर रखने), तो वे उपयोगकर्ता से 1..N प्रश्न पूछते हैं, तो वे इन प्रश्नों के परिणामों के आधार पर कुछ करते हैं (उदाहरण के लिए, वे डेटाबेस में प्रोफ़ाइल को सहेजते हैं)।

यदि एक पारंपरिक शैली (एक रिंग स्टाइल के बजाय) में एक बॉट लिखना संभव था, तो उपयोगकर्ता डेटा को सीधे स्टैक पर संग्रहीत करना संभव होगा।

चलो इसे करने की कोशिश करते हैं।

मैंने मॉड्यूल के एक स्केच को स्केच किया, जिससे आप इस लाइब्रेरी का उपयोग कर सकते हैं:

 #  - chat_dispatcher.py import asyncio class ChatDispatcher: class Timeout(RuntimeError): def __init__(self, last_message): self.last_message = last_message super().__init__('timeout exceeded') def __init__(self, *, chatcb, shardcb = lambda message: message.from_user.id, inactive_timeout = 15 * 60): self.chatcb = chatcb self.shardcb = shardcb self.inactive_timeout = inactive_timeout self.chats = {} async def handle(self, message): shard = self.shardcb(message) loop = asyncio.get_event_loop() if shard not in self.chats: self.chats[shard] = { 'task': self.create_chat(loop, shard), 'messages': [], 'wait': asyncio.Event(), 'last_message': None, } self.chats[shard]['messages'].append(message) self.chats[shard]['wait'].set() def create_chat(self, loop, shard): async def _chat_wrapper(): try: await self.chatcb(self.get_message(shard)) finally: del self.chats[shard] return loop.create_task(_chat_wrapper()) def get_message(self, shard): async def _get_message(inactive_timeout=self.inactive_timeout): while True: if self.chats[shard]['messages']: last_message = self.chats[shard]['messages'].pop(0) self.chats[shard]['last_message'] = last_message return last_message try: await asyncio.wait_for(self.chats[shard]['wait'].wait(), timeout=inactive_timeout) except asyncio.TimeoutError: self.chats[shard]['wait'].set() raise self.Timeout(self.chats[shard]['last_message']) if not self.chats[shard]['messages']: self.chats[shard]['wait'].clear() return _get_message 

थोड़ा स्पष्टीकरण:

ChatDispatcher वर्ग निम्न मापदंडों के साथ ChatDispatcher है:

1. आने वाले संदेशों के कार्य को तेज करना (इसे शार्डिंग क्यों कहा जाता है - बाद में, जब हम बड़े भार पर स्पर्श करते हैं)। फ़ंक्शन एक अद्वितीय संख्या देता है जो एक संवाद का संकेत देता है। उदाहरण में, यह केवल उपयोगकर्ता आईडी लौटाता है।
2. ऐसे कार्य जो चैट सेवा का कार्य करेंगे।
3. उपयोगकर्ता निष्क्रियता के लिए टाइमआउट मान।

नौकरी का विवरण:

1. उपयोगकर्ता के पहले संदेश के जवाब में, एक अतुल्यकालिक कार्य बनाया जाता है जो संवाद का काम करेगा। यह कार्य तब तक चलेगा जब तक संवाद पूरा नहीं हो जाता।
2. उपयोगकर्ता से एक संदेश प्राप्त करने के लिए, हम इसे स्पष्ट रूप से अनुरोध करते हैं। echo चैट उदाहरण:
   

    async def chat(get_message): message = await get_message() await message.answer(message.text) 

3. हम संदेशों का जवाब देते हैं क्योंकि लाइब्रेरी हमें प्रदान करती है ( message.answer )।

आइए इस प्रतिमान में एक बॉट लिखने का प्रयास करें

 #  bot.py import asyncio import re from .chat_dispatcher import ChatDispatcher import logging from aiogram import Bot, Dispatcher, executor, types API_TOKEN ='    ' logging.basicConfig(level=logging.INFO) bot = Bot(token=API_TOKEN) dp = Dispatcher(bot) async def chat(get_message): try: message = await get_message() await message.answer('  ,   ') first = await get_message() if not re.match('^\d+$', str(first.text)): await first.answer('  ,  : /start') return await first.answer('  ') second = await get_message() if not re.match('^\d+$', str(second.text)): await second.answer('  ,  : /start') return result = int(first.text) + int(second.text) await second.answer(' %s (/start - )' % result) except ChatDispatcher.Timeout as te: await te.last_message.answer('-   ,  ') await te.last_message.answer(' - /start') chat_dispatcher = ChatDispatcher(chatcb=chat, inactive_timeout=20) @dp.message_handler() async def message_handle(message: types.Message): await chat_dispatcher.handle(message) if __name__ == '__main__': executor.start_polling(dp, skip_updates=True) 

एक लिखित बॉट उदाहरण - यह बस संख्या के एक जोड़े को जोड़ता है और एक परिणाम पैदा करता है।

परिणाम इस तरह दिखता है:

खैर, अब कोड पर करीब से नज़र डालते हैं। उदाहरणों पर सवाल नहीं उठाना चाहिए।

हमारे स्केच के साथ एकीकरण मानक हैंडलर में किया जाता है जिसे हम await chat_dispatcher.handle(message) । और हमने chat फ़ंक्शन में chat का वर्णन किया, मैं इसका कोड यहां दोहराऊंगा:

 async def chat(get_message): try: message = await get_message() await message.answer('  ,   ') first = await get_message() if not re.match('^\d+$', str(first.text)): await first.answer('  ,  : /start') return await first.answer('  ') second = await get_message() if not re.match('^\d+$', str(second.text)): await second.answer('  ,  : /start') return result = int(first.text) + int(second.text) await second.answer(' %s (/start - )' % result) except ChatDispatcher.Timeout as te: await te.last_message.answer('-   ,  ') await te.last_message.answer(' - /start') 

चैट सेवा कोड - बस उपयोगकर्ता से एक-एक करके डेटा मांगता है। उपयोगकर्ता की प्रतिक्रियाएं केवल स्टैक पर खड़ी होती हैं (चर first , second , message )।

get_message फ़ंक्शन एक अपवाद फेंक सकता है यदि उपयोगकर्ता सेट टाइमआउट के दौरान कुछ भी दर्ज नहीं करता है (और आप उसी समय में टाइमआउट पास कर सकते हैं)।

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

कमियों

उनके बिना कहाँ।

1. प्रत्येक सक्रिय उपयोगकर्ता के लिए, एक कार्य-कोरुटिन है। औसतन, एक सीपीयू सामान्य रूप से लगभग 1000 उपयोगकर्ताओं को सेवा देता है, फिर देरी शुरू होती है।
2. पूरे डेमॉन को फिर से शुरू करना - सभी संवादों को समाप्त करता है (और उन्हें पुनरारंभ करता है)।
3. कोड [उदाहरण से] स्केलिंग और अंतर्राष्ट्रीयकरण को लोड करने के लिए अनुकूलित नहीं है।

यदि दूसरी समस्या के साथ यह स्पष्ट है कि क्या करना है: स्टॉप सिग्नल को इंटरसेप्ट करें और उपयोगकर्ताओं को बताएं "मेरे पास यहां एक आपातकालीन स्थिति है, आग, मैं थोड़ी देर बाद वापस आऊंगा।" वह आखिरी समस्या कठिनाइयों का कारण बन सकती है। आइए इसे देखें:

लोड स्केलिंग

जाहिर है, लोड किए गए बॉट को एक साथ कई बैकेंड पर लॉन्च किया जाना चाहिए। तदनुसार, ऑपरेशन के webHook मोड का उपयोग किया जाएगा।

यदि आप केवल webHook बीच संतुलन webHook , कहते हैं, दो बैकएंड, तो जाहिर है आपको किसी तरह यह सुनिश्चित करने की आवश्यकता है कि वही उपयोगकर्ता उसी webHook आता है जो उससे बात कर रहा है।

हमने इस प्रकार किया।

1. बैलेंसर पर, आने वाले संदेश ( message ) के JSON को पार्स करें
2. इसमें से एक यूजर आईडी चुनें
3. पहचानकर्ता का उपयोग करते हुए, हम बैकएंड नंबर (== शार्द) की गणना करते हैं। उदाहरण के लिए, user_id % Nshards का उपयोग user_id % Nshards ।
4. हम शार्क के अनुरोध को पुनर्निर्देशित करते हैं।

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

इस तरह के एक बैलेंसर का कोड सरल है - यह किसी भी भाषा में 10 मिनट में लिखा जाता है। मैं नहीं लाऊंगा।

निष्कर्ष

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

ज्यादातर लोग रिंग आर्किटेक्चर में बॉट क्यों लिखते हैं - मुझे नहीं पता।

वे ऐसे प्रतिमान में लिखते थे। इस शैली में चैट रूम की सेवा करना आईआरसी के युग में अपनाया गया था और इसके लिए बॉट बनाए गए थे। इसलिए मैं किसी भी प्रकार की नवीनता का ढोंग नहीं करता।

और अधिक। यदि आप इस प्रतिमान का उपयोग goto संचालक के साथ किसी भाषा में करते हैं, तो यह goto का उपयोग करने का एक सुंदर उदाहरण होगा (संवादों में लूप खूबसूरती से goto पर किया गया है)। दुर्भाग्य से यह पायथन के बारे में नहीं है।