def delegator_beard_gen(beards): for beard in beards: if hasattr(beard, "on_callback_query"): yield include_callback_query_chat_id(pave_event_space())( per_chat_id(), create_open, beard, timeout=beard._timeout) else: yield pave_event_space()(per_chat_id(), create_open, beard, timeout=beard._timeout)
def __init__(self, token, reply_threshold=60, botan_key=None): super(TeleApp, self).__init__(token, [ pave_event_space()( per_chat_id(), create_open, TeleChat, timeout=10), pave_event_space()( per_inline_from_id(), create_open, TeleInline, timeout=10) ]) self.reply_threshold = reply_threshold botan.set_key(botan_key) self._loop = asyncio.get_event_loop() self.username = self._loop.run_until_complete(self.getMe())['username']
def start(self, token): self.bot = telepot.aio.DelegatorBot(token, [ include_callback_query_chat_id( pave_event_space())( per_chat_id(), create_open, ShoppingUser, timeout=10), ]) self.loop.create_task(MessageLoop(self.bot).run_forever()) self.loop.run_forever()
def main(): bot = telepot.aio.DelegatorBot(TELEGRAM_TOKEN, [ pave_event_space()( per_chat_id(), create_open, MessageCounter, timeout=10), ]) loop = asyncio.get_event_loop() loop.create_task(MessageLoop(bot).run_forever()) loop.run_forever()
def main(): # ТУТ БУДЕТ НАШ КОД РАБОТЫ С БАЗОЙ ДАННЫХ # КОД ДАЛЬНЕЙШИХ ПРИМЕРОВ ВСТАВЛЯТЬ В ЭТО МЕСТО # Не забываем закрыть соединение с базой данных TOKEN = sys.argv[1] # get token from command-line bot = telepot.aio.DelegatorBot(TOKEN, [ pave_event_space()( per_chat_id(), create_open, AttendanceStarter, timeout=3), pave_event_space()( per_callback_query_origin(), create_open, Attendance, timeout=60), ]) loop = asyncio.get_event_loop() loop.create_task(MessageLoop(bot).run_forever()) print('Listening ...') loop.run_forever()
def main(): instagram_bot = InstagramAPI(INSTAGRAM_USERNAME, INSTAGRAM_PASSWORD) instagram_bot.login() bot = telepot.aio.DelegatorBot(config('TOKEN'), [ include_callback_query_chat_id(pave_event_space())( per_chat_id(types=['private']), create_open, GeneratePostChatHandler, timeout=10), ]) loop = asyncio.get_event_loop() loop.create_task(MessageLoop(bot).run_forever()) print('Listening ...') loop.run_forever()
def __init__(self, configuration): self._admins_telegram_ids = configuration.admins_telegram_ids self._delegator_bot = telepot.aio.DelegatorBot( configuration.token, [ # If the bot isn't chatting with an admin, skip, so for this # chat will be used another handler, not AdminHandler. pave_event_space()( per_from_id_in(self._admins_telegram_ids), create_open, AdminHandler, timeout=60, ), # If the bot is chatting with an admin, skip, so for this chat # will be used another handler, not StrangerHandler. pave_event_space()( per_from_id_except(self._admins_telegram_ids), create_open, StrangerHandler, timeout=60, ), ], )
def main(token): bot = telepot.aio.DelegatorBot(token, [ include_callback_query_chat_id(pave_event_space())( per_chat_id(types=['private']), create_open, LentaReader, timeout=10), ]) loop = asyncio.get_event_loop() loop.create_task(MessageLoop(bot).run_forever()) print('Listening ...') loop.run_forever()
def run(cls): token = os.environ['token'] # token = botconfig.token() bot = telepot.aio.DelegatorBot(token, [ pave_event_space()( per_chat_id(), create_open, cls, timeout=cls.timeout), ]) loop = asyncio.get_event_loop() loop.create_task(MessageLoop(bot).run_forever()) print('Listening ...') loop.run_forever()
def __init__(self, token, owner_id): self._owner_id = owner_id self._seen = set() self._store = UnreadStore() super(ChatBox, self).__init__(token, [ # Here is a delegate to specially handle owner commands. pave_event_space()( per_chat_id_in([owner_id]), create_open, OwnerHandler, self._store, timeout=20), # Only one MessageSaver is ever spawned for entire application. (per_application(), create_open(MessageSaver, self._store, exclude=[owner_id])), # For senders never seen before, send him a welcome message. (self._is_newcomer, call(self._send_welcome)), ])
def main(args=None): """The main routine""" if args is None: args = sys.argv[1:] bot = telepot.aio.DelegatorBot(TOKEN, [ include_callback_query_chat_id(pave_event_space())( per_chat_id(types=["group"]), create_open, DudoHandler, timeout=300), ]) loop = asyncio.get_event_loop() loop.create_task(MessageLoop(bot).run_forever()) loop.run_forever()
def __init__(self): self.token = open(config.TOKEN_FILE).read().strip() self._seen = set() super(BotManager, self).__init__(self.token, [ pave_event_space()( per_from_id_in(config.WHITELIST) if config.WHITELIST else per_from_id(), create_open, chatbot.ChatBot, None, timeout=10 * 60 ), ( per_application(), create_open(adminmonitor.AdminMonitor, config.ADMINS_LIST) ), ])
packname = msg['text'] try: await self.sender.sendChatAction('typing') await bot.addStickerToSet(self.from_id, packname, 'BQADBAADiQIAAlrMkFAokegTxHmJZAI', self.stickeremoji) await asyncio.sleep(10.0) setobj = await bot.getStickerSet(packname) testid = setobj['stickers'][-1]['file_id'] await bot.deleteStickerFromSet(testid) self.packname = packname self.packtitle = False self.packmade = True self.editing = True await self.sender.sendMessage(self.donemsg) except telepot.exception.TelegramError as e: await self.sender.sendMessage( 'Sorry you dont appear to be the owner of this pack or it doesnt exist.' ) print(e) bot = telepot.aio.DelegatorBot(key['telegram'], [ pave_event_space()(per_chat_id(), create_open, Stickers, timeout=70 * 1300), ]) loop = asyncio.get_event_loop() loop.create_task(MessageLoop(bot).run_forever()) print('Started...') loop.run_forever()
async def on_callback_query(self, msg): query_id, from_id, query_data = glance(msg, flavor='callback_query') print(msg) letter = { 'name': msg['from']['first_name'], 'chid': msg['message']['chat']['id'], 'type': '', 'orgn': msg['message']['text'] } q = query_data.split('♡') print(q) me = key_.adds('me') mew = key_.adds('mew') bot = telepot.aio.DelegatorBot(key_.kids('beta'), [ pave_event_space()(per_chat_id(), create_open, Emperor, timeout=3), pave_event_space()( per_callback_query_origin(), create_open, Slave, timeout=300), ]) sys.stdout = Unbuffered(sys.stdout) loop = asyncio.get_event_loop() loop.create_task(MessageLoop(bot).run_forever()) print('<--- --- Listening ... --- --->') loop.run_forever()
class MessageCounter(telepot.aio.helper.ChatHandler): def __init__(self, *args, **kwargs): super(MessageCounter, self).__init__(*args, **kwargs) self._count = 0 async def on_chat_message(self, msg): self._count += 1 await self.sender.sendMessage(self._count) TOKEN = sys.argv[1] PORT = int(sys.argv[2]) URL = sys.argv[3] bot = telepot.aio.DelegatorBot(TOKEN, [pave_event_space()(per_chat_id(), create_open, MessageCounter, timeout=10)]) update_queue = asyncio.Queue() # channel between web app and bot async def webhook(request): data = await request.text() await update_queue.put(data) # pass update to bot return web.Response(body="OK".encode("utf-8")) async def init(loop): app = web.Application(loop=loop) app.router.add_route("GET", "/abc", webhook) app.router.add_route("POST", "/abc", webhook) srv = await loop.create_server(app.make_handler(), "0.0.0.0", PORT)
question = intro[0]['X'] + self.symptom + '?' kb = ReplyKeyboardMarkup(keyboard=[['Yes', 'No']]) await bot.sendMessage(id, gesture + question, reply_markup=kb) self.previous_msg = 'Yes' elif (msg['text'] == 'Diagnose'): diagnose = list(self.prolog.query('diagnose(X)', maxresult=1)) self.diagnose = diagnose[0]['X'] if (self.diagnose == 'no_illness'): outcome = 'You are perfectly healthy! Do continue to exercise and keep fit!' else: outcome = 'Based on the symptom(s), you are likely to have {}. Please visit the nearby clinic to get help.'.format( self.diagnose) await bot.sendMessage(id, outcome) exit() TOKEN = "1150310497:AAEYmBDdkP21yfCmQR6xd4E2VSPR5p0UNnY" bot = telepot.aio.DelegatorBot(TOKEN, [ pave_event_space()( per_chat_id(), create_open, PrologInteractor, timeout=500), ]) loop = asyncio.get_event_loop() loop.create_task(MessageLoop(bot).run_forever()) print('Listening ...') loop.run_forever()
self.prolog = Prolog() self.prolog.consult('Askid.pl') self.unused_activities = list(self.activities.keys()) self.question = random.choice(list(self.activities.keys())) self.activity = self.question self.prolog.assertz('curr({})'.format(self.question)) else: self.question = random.choice(self.unused_activities) self.activity = self.question self.prolog.assertz('curr({})'.format(self.question)) self.prolog.query("assert(asked('{}'))".format( self.activities[self.question])) kb = ReplyKeyboardMarkup(keyboard=[['YES', 'NO']]) # await self.sender.sendMessage(self.activities[self.question], reply_markup = kb) await bot.sendMessage(id, self.activities[self.question], reply_markup=kb) # get token from command-line TOKEN = <YOUR TOKEN> bot = telepot.aio.DelegatorBot(TOKEN, [ pave_event_space()( per_chat_id(), create_open, PrologReplier, timeout=500), ]) loop = asyncio.get_event_loop() loop.create_task(MessageLoop(bot).run_forever()) print('Listening ...') loop.run_forever()
class MessageHandler(telepot.aio.helper.ChatHandler): def __init__(self, *args, **kwargs): super(MessageHandler, self).__init__(*args, **kwargs) async def on_chat_message(self, msg): if msg["from"]["id"] == SECRETS.CHAT_ID: await on_chat_Handler(msg, SECRETS.CHAT_ID) else: pass # send telegram message async def send_telegram_msg(msg): try: await bot.sendMessage(SECRETS.CHAT_ID, msg) except: pass # initialize telegram bot = telepot.aio.DelegatorBot(API_KEY, [ pave_event_space()(per_chat_id(), create_open, MessageHandler, timeout=20), ]) loop = asyncio.get_event_loop() loop.create_task(MessageLoop(bot).run_forever()) client.run(SECRETS.TOKEN) print('Listening ...') loop.run_forever()
if guess != self._answer: response = requests.get('http://numbersapi.com/' + str(guess), headers=headers, params=params) # give a descriptive hint hint = self._hint(self._answer, guess) await self.sender.sendMessage("try something " + hint + "\n" + response.text) else: await self.sender.sendMessage('Correct!') self.close() async def on__idle(self, event): await self.sender.sendMessage( 'Game expired. The answer is %d.\n Please frequent the @VergeZoo \n Calling out @XVGPufferfish, @GorillaChain, @Simple_Dolphin, and @XVGHawk' % self._answer) self.close() TOKEN = sys.argv[1] bot = telepot.aio.DelegatorBot(TOKEN, [ pave_event_space()(per_chat_id(), create_open, Player, timeout=60), ]) loop = asyncio.get_event_loop() loop.create_task(MessageLoop(bot).run_forever()) print('Listening ...') loop.run_forever()
print('data path: ' + data_path) formatter = logging.Formatter('%(asctime)s | %(levelname)s | %(message)s') stream_logger = logging.StreamHandler() stream_logger.setFormatter(formatter) stream_logger.setLevel(logging.DEBUG) logging.basicConfig(level=logging.DEBUG, handlers=[stream_logger]) loop = asyncio.get_event_loop() registry = session.SessionRegistry() bot = telepot.aio.DelegatorBot( token, [pave_event_space()( per_chat_id(), create_open, session.Session, data_path, loop, registry, timeout=20 * 60)], loop ) loop.create_task(bot.message_loop()) def sigint_handler(): logging.info('SIGINT') try: registry.close_all() except Exception as e: logging.error(e) finally: loop.stop() loop.add_signal_handler(signal.SIGINT, sigint_handler)
# db = shelve.open("session.db", "c", writeback=True) atexit.register(lambda: k.saveBrain('brain.sav')) k = Kernel() # sessionStore=db) k.learn("startup.xml") k.respond("load aiml b") class MessageKiller(telepot.aio.helper.ChatHandler): def __init__(self, *args, **kwargs): super(MessageKiller, self).__init__(*args, **kwargs) async def on_chat_message(self, msg): print("Message text ", msg["text"]) res = k.respond(msg["text"]).replace(" ", " ").replace(" ", " ") print("Response ", res) await self.sender.sendMessage(res) TOKEN = "here_goes_bot_token" bot = telepot.aio.DelegatorBot(TOKEN, [ pave_event_space()(per_chat_id(), create_open, MessageKiller, timeout=30), ]) loop = asyncio.get_event_loop() loop.create_task(MessageLoop(bot).run_forever()) print('Listening ...') loop.run_forever()
""" $ python3.5 countera.py <token> Counts number of messages a user has sent. Starts over if silent for 10 seconds. Illustrates the basic usage of `DelegateBot` and `ChatHandler`. """ class MessageCounter(telepot.aio.helper.ChatHandler): def __init__(self, *args, **kwargs): super(MessageCounter, self).__init__(*args, **kwargs) self._count = 0 async def on_chat_message(self, msg): self._count += 1 await self.sender.sendMessage(self._count) TOKEN = sys.argv[1] # get token from command-line bot = telepot.aio.DelegatorBot(TOKEN, [ pave_event_space()( per_chat_id(), create_open, MessageCounter, timeout=10), ]) loop = asyncio.get_event_loop() loop.create_task(bot.message_loop()) print('Listening ...') loop.run_forever()
chunk_size = len(lst) // chunk_count return [lst[i:i + chunk_size] for i in range(0, len(lst), chunk_size)] ''' keyboard = InlineKeyboardMarkup(inline_keyboard=[ [InlineKeyboardButton(text='Press me', callback_data='4')], ]) bot.sendMessage(chat_id, 'Use inline keyboard', reply_markup=keyboard) ''' TOKEN = sys.argv[1] # get token from command-line # bot = telepot.aio.Bot(TOKEN) bot = telepot.aio.DelegatorBot(TOKEN, [ pave_event_space()( per_chat_id(), create_open, SheluderStarter, timeout=3), pave_event_space()( per_callback_query_origin(), create_open, Sheluder, timeout=60), ]) loop = asyncio.get_event_loop() loop.create_task(MessageLoop(bot).run_forever()) print('Listening ...') loop.run_forever()
async def on_chat_message(self, msg): cid = self.chat_id content_type, chat_type, chat_id = telepot.glance(msg) if content_type != 'text': return text = msg['text'] if not text.startswith(BOT_PREFIX): return if msg['text'] != (BOT_PREFIX + 'sub'): return SUBSCRIBED_CHAT_ID.add(cid) await self.sender.sendMessage('Subscribed to updates') TOKEN = sys.argv[1] # get token from command-line bot = telepot.aio.DelegatorBot(TOKEN, [ pave_event_space()(per_chat_id(), create_open, Idler, timeout=10), ]) loop = asyncio.get_event_loop() loop.create_task(MessageLoop(bot).run_forever()) print('Listening ...') loop.run_forever()
if content_type == 'text': sent = await bot.sendInvoice( chat_id, "Nick's Hand Cream", "Keep a man's hand like a woman's", payload='a-string-identifying-related-payment-messages-tuvwxyz', provider_token=PAYMENT_PROVIDER_TOKEN, start_parameter='abc', currency='HKD', prices=[ LabeledPrice(label='One Case', amount=987), LabeledPrice(label='Package', amount=12)], need_shipping_address=True, is_flexible=True) # required for shipping query print('Invoice sent:') pprint(sent) TOKEN = sys.argv[1] PAYMENT_PROVIDER_TOKEN = sys.argv[2] bot = telepot.aio.DelegatorBot(TOKEN, [ (per_message(flavors=['chat']), call(send_invoice)), pave_event_space()( per_invoice_payload(), create_open, OrderProcessor, timeout=30, ) ]) loop = asyncio.get_event_loop() loop.create_task(MessageLoop(bot).run_forever()) loop.run_forever()
if not self.prolog.selectable_input_options("sauces"): await self.__updateCounter() elif user_input in self.prolog.all_options("topups"): self.prolog.add_topup(user_input) if not self.prolog.selectable_input_options("topups"): await self.__updateCounter() elif user_input in self.prolog.all_options("sides"): self.prolog.add_side(user_input) if not self.prolog.selectable_input_options("sides"): await self.__updateCounter() await self.__ask(id, bot, self.question_lists[self.counter]) else: self.prolog.add_drink(user_input) await self.__ask(id, bot, None) bot = telepot.aio.DelegatorBot(TOKEN, [ pave_event_space()(per_chat_id(), create_open, TelegramBot, timeout=500), ]) loop = asyncio.get_event_loop() loop.create_task(MessageLoop(bot).run_forever()) print('Listening ...') loop.run_forever()
# 2. Define event-handling function async def on__alarm(self, event): print(event) # see what the event object actually looks like await self.sender.sendMessage('Beep beep, time to wake up!') async def on_chat_message(self, msg): try: delay = float(msg['text']) # 3. Schedule event # The second argument is the event spec: a 2-tuple of (flavor, dict). # Put any custom data in the dict. Retrieve them in the event-handling function. self.scheduler.event_later(delay, ('_alarm', {'payload': delay})) await self.sender.sendMessage('Got it. Alarm is set at %.1f seconds from now.' % delay) except ValueError: await self.sender.sendMessage('Not a number. No alarm set.') TOKEN = sys.argv[1] bot = telepot.aio.DelegatorBot(TOKEN, [ pave_event_space()( per_chat_id(), create_open, AlarmSetter, timeout=10), ]) loop = asyncio.get_event_loop() loop.create_task(MessageLoop(bot).run_forever()) print('Listening ...') loop.run_forever()
def _make_per_chat_handler(handler, **kwargs): return pave_event_space()(per_chat_id(), create_open, handler, **kwargs)
if query_data != 'start': self._score[self._answer == int(query_data)] += 1 self._answer = await self._show_next_question() async def on__idle(self, event): text = '%d out of %d' % (self._score[True], self._score[True]+self._score[False]) await self.editor.editMessageText( text + '\n\nThis message will disappear in 5 seconds to test deleteMessage', reply_markup=None) await asyncio.sleep(5) await self.editor.deleteMessage() self.close() TOKEN = sys.argv[1] bot = telepot.aio.DelegatorBot(TOKEN, [ pave_event_space()( per_chat_id(), create_open, QuizStarter, timeout=3), pave_event_space()( per_callback_query_origin(), create_open, Quizzer, timeout=10), ]) loop = asyncio.get_event_loop() loop.create_task(MessageLoop(bot).run_forever()) print('Listening ...') loop.run_forever()
parse_mode="Markdown") self.waiting_reponse = False #if detect any command from other bot answer with a custom message and return a photo elif any(word in msg['text'] for word in self.antibot_keywords) and self.warmode: await self.sender.sendMessage(self.cfg['messages']['antibot']) await self.sender.sendPhoto(self.request_image()) #This should be improved TODO with open(sys.argv[1] + "/config.yaml", 'r') as yamlfile: cfg = yaml.safe_load(yamlfile) TOKEN = cfg['bot']['token'] #read the telegram bot token from the config file # create a handler for each telegram chat with a lifespan of "timeout" # if timeout is reached without any new messages it will be destroyed bot = telepot.aio.DelegatorBot(TOKEN, [ pave_event_space()(per_chat_id(), create_open, OfftopicBotHandler, timeout=cfg['bot']['timeout']), ]) loop = asyncio.get_event_loop() loop.create_task(MessageLoop(bot).run_forever()) print('Listening ...') loop.run_forever()
async def on__idle(self, event): self.close() dotenv_path = join(dirname(__file__), '.env') if (load_dotenv(dotenv_path)): TOKEN = os.environ.get("TELEGRAM_BOT_TOKEN") SPEECH_KIT_API_KEY = os.environ.get("SPEECH_KIT_API_KEY") DEBUG = os.environ.get("DEBUG") else: TOKEN = sys.argv[1] # get token from command-line if ((SPEECH_KIT_API_KEY != '') and (SPEECH_KIT_API_KEY)): bot = telepot.aio.DelegatorBot(TOKEN, [ include_callback_query_chat_id(pave_event_space())( per_chat_id(types=['private']), create_open, Speech2TextBot, SPEECH_KIT_API_KEY, timeout=40), ]) loop = asyncio.get_event_loop() loop.create_task(bot.message_loop()) print('Listening ...') loop.run_forever() else: print('Please regester your Yandex Speech Kit API Key at \
await self.sender.sendMessage('Time is up:\nYes: %d\nNo: %d\nSilent: %d' % result) def on_close(self, ex): global votes if self._ballot_box is None: try: del votes[self.id] except KeyError: pass else: votes[self.id] = (self._ballot_box, self._keyboard_msg_ident, self._expired_event, self._member_count) from pprint import pprint print('%d closing ...' % self.id) pprint(votes) TOKEN = sys.argv[1] bot = telepot.aio.DelegatorBot(TOKEN, [ include_callback_query_chat_id( pave_event_space())( per_chat_id(types=['group']), create_open, VoteCounter, timeout=10), ]) loop = asyncio.get_event_loop() loop.create_task(bot.message_loop()) print('Listening ...') loop.run_forever()
def compute_answer(): query_id, from_id, query_string = telepot.glance(msg, flavor='inline_query') print(self.id, ':', 'Inline Query:', query_id, from_id, query_string) articles = [{'type': 'article', 'id': 'abc', 'title': query_string, 'message_text': query_string}] return articles self.answerer.answer(msg, compute_answer) def on_chosen_inline_result(self, msg): from pprint import pprint pprint(msg) result_id, from_id, query_string = telepot.glance(msg, flavor='chosen_inline_result') print(self.id, ':', 'Chosen Inline Result:', result_id, from_id, query_string) TOKEN = sys.argv[1] bot = telepot.aio.DelegatorBot(TOKEN, [ pave_event_space()( per_inline_from_id(), create_open, InlineHandler, timeout=10), ]) loop = asyncio.get_event_loop() loop.create_task(MessageLoop(bot).run_forever()) print('Listening ...') loop.run_forever()
for category in highscores_categories: if char.get(category, None): highscore_string = highscore_format[category].format( pronoun2, char[category], char[category + '_rank']) reply += "\n🏆 {0}".format(highscore_string) return reply def on_close(self, ex): yield from self.sender.sendMessage('Fechou') class ChatBox(telepot.aio.DelegatorBot): def __init__(self, token): super(ChatBox, self).__init__(token, [ pave_event_space()(per_chat_id(), create_open, Tibia, timeout=10), ]) #TOKEN = sys.argv[1] # get token from command-line TOKEN = '344437874:AAEXStWb9DM3S6FhtWC-jlWULgv-1gyoWLU' #TOKEN = '283648340:AAE6n-MG0ZEj_5rwBypeR1aN5yp7a7W7NwY' #bot = ChatBox(TOKEN) bot = telepot.aio.DelegatorBot(TOKEN, [ pave_event_space()(per_chat_id(), create_open, Tibia, timeout=10), ]) loop = asyncio.get_event_loop() loop.create_task(bot.message_loop()) print('Listening ...') loop.run_forever()
return web.Response(body='OK'.encode('utf-8')) async def init(app, bot): app.router.add_route('GET', '/webhook', feeder) app.router.add_route('POST', '/webhook', feeder) await bot.setWebhook(URL) TOKEN = sys.argv[1] PORT = int(sys.argv[2]) URL = sys.argv[3] loop = asyncio.get_event_loop() app = web.Application(loop=loop) bot = telepot.aio.DelegatorBot(TOKEN, [ pave_event_space()( per_chat_id(), create_open, MessageCounter, timeout=10)], loop=loop) webhook = OrderedWebhook(bot) loop.run_until_complete(init(app, bot)) loop.create_task(webhook.run_forever()) try: web.run_app(app, port=PORT) except KeyboardInterrupt: pass
def __init__(self, token): super(ChatBox, self).__init__(token, [ pave_event_space()(per_chat_id(), create_open, Tibia, timeout=10), ])
if 'favourite' in query_data: download_to = query_data.strip('favourite_') with open(torrents_cfg['t_file_magnet'], 'rb') as hFile: torrent = pickle.load(hFile) try: self.command.torrent_add(torrent['torrent'], download_dir=favourites[download_to]) await self.bot.sendMessage(from_id, "Link has been added to the queue", reply_markup=None) await self.show_torrents_list(from_id) except Exception as e: await self.bot.sendMessage(from_id, e, reply_markup=None) async def on__idle(self, event): await asyncio.sleep(1) self.close() teletor = telepot.aio.DelegatorBot(telegram_bot['token'], [ pave_event_space()(per_chat_id(), create_open, TorrentBot, timeout=10), pave_event_space()( per_callback_query_origin(), create_open, TorrentBot, timeout=10), ]) if __name__ == '__main__': loop = asyncio.get_event_loop() loop.create_task(teletor.message_loop()) loop.run_forever()
except ValueError: await self.sender.sendMessage('Give me a number, please.') return # check the guess against the answer ... if guess != self._answer: # give a descriptive hint hint = self._hint(self._answer, guess) await self.sender.sendMessage(hint) else: await self.sender.sendMessage('Correct!') self.close() async def on__idle(self, event): await self.sender.sendMessage('Game expired. The answer is %d' % self._answer) self.close() TOKEN = sys.argv[1] bot = telepot.aio.DelegatorBot(TOKEN, [ pave_event_space()( per_chat_id(), create_open, Player, timeout=10), ]) loop = asyncio.get_event_loop() loop.create_task(MessageLoop(bot).run_forever()) print('Listening ...') loop.run_forever()