Question

我正在开发一种用于聊天消息，内联按钮和内联查询的电报机器人

在实现即时查询的同时，我还遇到了一些使聊天消息正常工作的问题。

目前，除了聊天消息之外，其他所有东西都正常运行，如果用户发送了聊天消息，则漫游器会接收到该消息，但是如果用户在超时时间（10秒）之前发送了另一个聊天消息，则该漫游器可以拦截它。

可能是在DelegatorBot中，我设置了一些错误的参数。也许MsgWriten类的参数不正确。

我将在下面的配置中附加该机器人的“骨架”代码，这很基本，如果您发送/start，它将回复一条消息和一个按钮，如果单击该按钮，它将向您显示一条通知，如果您内联调用查询，它将回复您。

真正的问题是，当您发送随机聊天消息时，它应该在每条聊天消息上都回复您，但是，正如我之前所说的，只要您等待10秒钟，它就会回复您。

代码如下：

import time
import telepot
from telepot.loop import MessageLoop
from telepot.delegate import pave_event_space, per_chat_id, create_open, \
    include_callback_query_chat_id, per_inline_from_id
from telepot.namedtuple import InlineKeyboardMarkup, InlineKeyboardButton
from telepot.namedtuple import InlineQueryResultArticle, InputTextMessageContent

import settings


class MsgWriten(telepot.helper.InlineUserHandler, telepot.helper.AnswererMixin):

    def __init__(self, *args, **kwargs):
        super(MsgWriten, self).__init__(*args, **kwargs)
        print(self)
        self._count = 0

    def on_chat_message(self, msg):
        global messages_ids

        content_type, chat_type, chat_id = telepot.glance(msg)
        print('Chat message: ', content_type, chat_type, chat_id)

        if content_type == 'text':
            txt = msg['text']
            keyboard = InlineKeyboardMarkup(inline_keyboard=[
                [InlineKeyboardButton(text='Query data text 1',
                                     parse_mode='Markdown',
                                     callback_data='test1')]
            ])

            if txt.startswith('/start'):
                bot.sendMessage(chat_id, 'Start command', reply_markup=keyboard)
            else:
                bot.sendMessage(chat_id, text=txt)

    def on_callback_query(self, msg):
        global messages_ids

        query_id, chat_id, query_data = telepot.glance(msg, flavor='callback_query')
        print('Callback query:', query_id, chat_id, query_data)

        if query_data == 'test1':
            bot.answerCallbackQuery(query_id, text='Query data text 1')

    def on_inline_query(self, msg):
        def compute():
            query_id, from_id, query_string = telepot.glance(msg, flavor='inline_query')
            print('Computing for: %s' % query_string)

            articles = [InlineQueryResultArticle(
                id='abcde', title='Telegram',
                input_message_content=InputTextMessageContent(message_text='Telegram is a messaging app')),
                dict(type='article',
                     id='fghij', title='Google', input_message_content=dict(message_text='Google is a search engine'))]

            return articles

        self.answerer.answer(msg, compute)

    def on_chosen_inline_result(self, msg):
        result_id, from_id, query_string = telepot.glance(msg, flavor='chosen_inline_result')
        print('Chosen Inline Result:', result_id, from_id, query_string)

TOKEN = sys.argv[1]  # get token from command-line

bot = telepot.DelegatorBot(TOKEN, [
    include_callback_query_chat_id(
            pave_event_space())(
            per_chat_id(), create_open, MsgWriten, timeout=10),
    pave_event_space()(
        per_inline_from_id(), create_open, MsgWriten, timeout=10)
])

MessageLoop(bot).run_as_thread()

while 1:
    time.sleep(10)

正如我所说，这不是我真正的机器人，只是一些测试的框架。其目标是即使用户发送的聊天消息非常迅速，也能够拦截聊天消息，并使回调查询和内联查询也能正常工作。

谢谢

适用于聊天和内联的Telepot

0 个答案: