Контекст диалога в pytelegrambotapi

Контекст в чат-ботах играет ключевую роль в создании удобных и интерактивных взаимодействий с пользователем. Без него бот теряет связь с предыдущими сообщениями, что усложняет диалог. В этой статье мы рассмотрим, как реализовать систему контекстных диалогов на Python с использованием библиотеки telebot. Мы покажем, как управлять состоянием диалога, сохранять контекст и обрабатывать несколько пользователей одновременно, делая бота более умным и персонализированным.

Зачем нужен контекст диалога?

Я думаю, вы часто, пользуясь телеграмм-ботами, вводите какую-то кастомную информацию, например цену товара, при этом не задумываясь, как сервис понимает, что ваше сообщение — это именно цена, а не имя или описание, очевидно, по предыдущему сообщению, где бот спрашивает о цене, спросил — ответили. Это и называют контекстом разговора. Другой пример — любой анонимный чат, боту нужно помнить, с каким пользователем вы говорите, он это знает, ведь он вас с ним и связал. Таким образом, без контекста диалога вам придётся каждый раз сообщать, что это такое, а далеко не все хотят разбираться, на кой чёрт вам 100500 команд с названием /add_name, /add_price, /add_description, и рано или поздно все запутаются.

Способы реализации

Я буду рассматривать именно библиотеку telebot, хотя в других, более продвинутых, есть крутые встроенные инструменты, например в python-telegram-bot, но в них чёрт ногу сломит, поскольку я немного ленивый низкоквалифицированный, я остановлюсь на pytelegrambotapi.
Первое, что придёт в голову большинству, это создать словарь для всех текущих диалогов, что-то по типу:

states = {user_id: "name"}

Если ваш бот состоит из больше чем пары команд и менюшек, скорее вы запутаетесь, как рулить, городя огород в универсальном хендлере, чем напишите что-то работающее.

Далее за ответом я полез к универсальному хранителю знаний — Чату ГПТ, который уже посоветовал более релевантное решение, встроенное в самого telebot’а: стейты, это уже более продвинутое решение, которое подходит для получения пользовательского ввода, но всё же не лишено минусов, например контекст всё ещё отсутствует, это просто стейты, хоть теперь мы и можем придерживаться технологии вопрос-ответ, но диалога выстроить нормально не получится без создания сторонних словарей.

3-й способ был собран мной из подручных материалов на коленке за 2 дня, аналогов я не нашёл, и поэтому заявляю, что это мой гриб и я его ем. Это библиотека telebot-dialogues, она позволяет создавать диалоги для пользователей с сохранением контекстных переменных, истории сообщений и приостановкой диалога.

Также хочу обратить внимание что message.from_user.id НЕ эквивалентно call.message.from_user.id, на деле message.from_user.id = call.message.chat.id

Теперь рассмотрим каждый способ подробней.

Метод в лоб

Смысл прост: создаём словарь, где ключи — это айдишники юзеров, а значения — их состояния, и погнали проверять их в хендлере всего, в общем виде реализация выглядит так:

классно, да? Вроде работает, но что если нам нужно чуть больше чем имя, возраст например. Пока логично, просто изменяем take_name и главный хендлер:

@bot.message_handler(content_types=["text"]) def handle_text(message):     state = states.get(message.from_user.id)     match state:         case 'name':             take_name(message)         case 'age':             take_age(message)              def take_name(message):     bot.send_message(message.chat.id, f'твоё имя: {message.text}! Введи свой возраст')     states[message.from_user.id] = 'age'

и соответственно добавляем:

def take_age(message):     bot.send_message(message.chat.id, f'твой возраст: {message.text} лет!')     states[message.from_user.id] = None

А сохранять эти данные как? Вроде логично прикурить сохранение в файл или БД, но что, если сохранить нужно всё разом, тогда придётся использовать ещё один костыль: временное хранилище.

temp_info_save = {}

и соответственно изменяем всё под новые суровые реалии:

def take_name(message):     bot.send_message(message.chat.id, f'твоё имя: {message.text}!')     temp_info_save[message.from_user.id] = {'name': message.text}     states[message.from_user.id] = 'age'  def take_age(message):     bot.send_message(message.chat.id, f'твой возраст: {message.text} лет!')     temp_info_save[message.from_user.id]['age'] = message.text     states[message.from_user.id] = None 

Конечно, можно добавить и сохранение истории сообщений, и состояния и т. д., но я думаю, вы скорее головой тронетесь, чем напишите это в более-менее адекватном виде, так что этот способ можно хоронить.

Окончательный код:

from telebot import TeleBot  bot = TeleBot('YOUR_BOT_TOKEN')  states = {} temp_info_save = {}  @bot.message_handler(commands=['start']) def start_command(message):     states[message.user_from.id] = 'name'     bot.send_message(message.chat.id, 'Привет! Введи своё имя.')  @bot.message_handler(content_types=["text"]) def handle_text(message):     state = states.get(message.from_user.id)     match state:         case 'name':             take_name(message)             bot.send_message(message.chat.id, f'Привет, {message.text}! Введи свой возраст.')          case 'age':             take_age(message)             bot.send_message(message.chat.id, 'Теперь ты можешь отправлять мне сообщения.')   def take_name(message):     bot.send_message(message.chat.id, f'твоё имя: {message.text}!')     temp_info_save[message.from_user.id] = {'name': message.text}     states[message.from_user.id] = 'age'  def take_age(message):     bot.send_message(message.chat.id, f'твой возраст: {message.text} лет!')     temp_info_save[message.from_user.id]['age'] = message.text     states[message.from_user.id] = None   if __name__ == '__main__':     bot.polling()

Уже имеющийся контроллер состояний

По сути этот метод не многим отличается от предыдущего, но он хотя-бы выглядит прилично.

import telebot from telebot import types from telebot.handler_backends import State, StatesGroup  bot = telebot.TeleBot('YOUR_BOT_TOKEN')  class UserState(StatesGroup):     waiting_for_name = State()  # Состояние ожидания имени  @bot.message_handler(commands=['start']) def start_command(message):     bot.set_state(message.chat.id, UserState.waiting_for_name)     bot.send_message(message.chat.id, 'Привет! Введи своё имя.')  @bot.message_handler(content_types=["text"], state=UserState.waiting_for_name) def take_name(message):     user_name = message.text     bot.send_message(message.chat.id, f'Твоё имя: {user_name}!')          bot.delete_state(message.chat.id)  # Запуск бота if __name__ == '__main__':     bot.polling() 

Великолепно, очевидным плюсом будет отсутствие центрального хендлера, на этом плюсы кончились, в остальном это такой же словарь, только оформленный в виде класса, а вместо строк состояний стейты, но для сохранения данных между сообщениями также понадобится создавать словарь, вот пример реализации:

import telebot from telebot import types from telebot.handler_backends import State, StatesGroup  bot = telebot.TeleBot('YOUR_BOT_TOKEN')  temp_info_save = {}  class UserState(StatesGroup):     waiting_for_name = State()  # Состояние ожидания имени     waiting_for_age = State()   # Состояние ожидания возраста  @bot.message_handler(commands=['start']) def start_command(message):     # Устанавливаем состояние ожидания имени     bot.set_state(message.chat.id, UserState.waiting_for_name)     bot.send_message(message.chat.id, 'Привет! Введи своё имя.')  @bot.message_handler(content_types=["text"], state=UserState.waiting_for_name) def take_name(message):     user_name = message.text     bot.send_message(message.chat.id, f'Твоё имя: {user_name}!')          temp_info_save[message.chat.id] = {'name': user_name}          bot.set_state(message.chat.id, UserState.waiting_for_age)     bot.send_message(message.chat.id, f'Привет, {user_name}! Введи свой возраст.')  @bot.message_handler(content_types=["text"], state=UserState.waiting_for_age) def take_age(message):     user_age = message.text     bot.send_message(message.chat.id, f'Твой возраст: {user_age} лет!')          temp_info_save[message.chat.id]['age'] = user_age          bot.delete_state(message.chat.id)          bot.send_message(message.chat.id, 'Теперь ты можешь отправлять мне сообщения.')  if __name__ == '__main__':     bot.polling()

Да, это ровно то же самое, что мы делали в предыдущем способе, только по-умному, подводя итог: способ сильно лучше, но по сути является тем же самым.

Мой вариант

Потратив два дня не очень активной мыслительной деятельности я сообразил библиотеку telebot-dialoguesустановка как обычно:

pip install telebot-dialogue

И да, это такой же словарь, но с красивой обёрткой, но моя обёртка — приемлемый интерфейс для взаимодействия, всё строится на двух слонах и одном слонёнке: Dialogue, DialogueManager и DialogueUpdater, первый, как следует из названия, является объектом диалога, второй — менеджером, а третий — это подкласс менеджера, чтобы не делать кучу функций под обновление переменных, вы просто редактируете информацию в контекстом менеджера.

from telebot import TeleBot from telebot_dialogue import DialogueManager, Dialogue  bot = TeleBot("Your_BOT_TOKEN") dialogue_manager = DialogueManager()  @bot.message_handler(commands=['start']) def start_command(message):     user_id = message.from_user.id     dialogue = Dialogue(user_id, take_name, end_func=end_dialogue)     dialogue_manager.add_dialogue(dialogue)      # если диалог с этим пользователем уже есть то новый не начнётся, force=True заменяет диалог     bot.send_message(message.chat.id, 'Привет! напиши своё имя:')  def end_dialogue(dialogue):     bot.send_message(dialogue.user_id,                      f'Завершение диалога, вот твоя инфа имя: {dialogue.get_context('name')}, '                      f'возраст: {dialogue.get_context('age')}')   def take_age(message, dialogue):     age = int(message.text)     with dialogue_manager.update(dialogue.user_id) as update_dialogue:         update_dialogue.update_context('age', age)         bot.send_message(message.chat.id, 'Спасибо! Тебе {} лет.'.format(age))         context = update_dialogue.get_context('name')          print(context) # типа сохранение в дб         update_dialogue.delete_dialogue()   def take_name(message, dialogue):     name = message.text     with dialogue_manager.update(dialogue.user_id) as update_dialogue:         update_dialogue.update_context('name', name)         bot.send_message(message.chat.id, 'Доброго утра, {}! Сколько тебе лет?'.format(name))         update_dialogue.handler = take_age  @bot.message_handler(content_types=['text']) def handle_text(message):     if not dialogue_manager.handle_message(message): # Если диалога нет, то отправляем приветствие         bot.send_message(message.chat.id, 'Привет! Это бот для общения с пользователем. напиши /start, чтобы начать.')   if __name__ == '__main__':     bot.polling()

Громоздко? Очень, зато потенциал куда больше, чем у предыдущих способов, это может быть использовано при публикации объявления, когда нужно заполнить форму, и хранить всё отдельно неудобно. А теперь можно перейти к более сложным функциям этой библиотеки:

История

Все сообщения сохраняются в истории сообщений, в виде обычного списка, вы можете получить к ним доступ как-то так:

def end_dialogue(dialogue):     bot.send_message(dialogue.user_id,                      f'Завершение диалога, вот твоя инфа имя: {dialogue.get_context('name')}, '                      f'возраст: {dialogue.get_context('age')} твоё первое сообщение - {dialogue.history[0].text}.')

Статус

например если в анонимном чате пользователь решит приостановить общение, то вызывается dialogue.stop_dialogue(), вызывающая функцию pause_func, dialogue.continue_dialogue() делает ровно противоположное, вызывает функцию continue_func, dialogue.delete_dialogue() вызывает end_func и завершает диалог. Функции pause_func, continue_func и end_func передаются при создании диалога. При приостановке и возобновлении меняется статус. Хендлер работает только с state=true

Контекст и сброс

update_context(key, value) добавляется в контекст данные в формате ключ значение,
get_context(key, default=None) получает данные из контекста по ключу
clear_context и clear_history делают ровно то, что вы от них ожидаете
reset_dialogue сбрасывает диалог до заводских(уничтожает историю и контекст)

Менеджер

continue_dialogue, finish_dialogue и stop_dialogue являются оболочками и просто вызывают соответствующие функции у диалога по user_id

Контекстный updater

Вы можете менять любые параметры диалога через контекстный менеджер и функцию update у менеджера,

with manager.update(user_id) as dialogue:   # любые действия с дилогом   dialogue.handler = new_handler  print(manager.find_dialogue(user_id).handler) # new_handler

Пример анонимного чата со всеми функциями

from telebot import TeleBot from telebot_dialogue import DialogueManager, Dialogue  bot = TeleBot("YOUR_BOT_TOKEN") dialogue_manager = DialogueManager()   @bot.message_handler(commands=['start']) def find_conversation(message):     user_id = message.from_user.id     partner = '123' # поиск собеседника     if not dialogue_manager.find_dialogue(user_id):         dialogue = Dialogue(user_id, conversate, end_func=end_dialogue, context={'partner': partner})         dialogue_manager.add_dialogue(dialogue)         bot.send_message(message.chat.id, 'Привет! мы нашли тебе собеседника, можешь с ним поговорить:')              with dialogue_manager.update(user_id) as update_dialogue:         update_dialogue.clear_context()         update_dialogue.update_context('partner', partner)   def end_dialogue(dialogue):     bot.send_message(dialogue.user_id, 'Диалог завершен.')     bot.send_message(dialogue.get_context('partner'), 'Твой собеседник завершил диалог.')   def conversate(message, dialogue):     bot.send_message(dialogue.get_context('partner'), message.text)   @bot.message_handler(commands=['pause']) def pause_dialogue_handler(message):     user_id = message.from_user.id     if dialogue_manager.stop_dialogue(user_id):         return      bot.send_message(message.chat.id, 'у тебя нет активного диалога. Напиши /start, чтобы начать.')  @bot.message_handler(commands=['continue']) def continue_dialogue_handler(message):     user_id = message.from_user.id     if dialogue_manager.continue_dialogue(user_id):         return      bot.send_message(message.chat.id, 'у тебя нет активного диалога. Напиши /start, чтобы начать.')  @bot.message_handler(content_types=['text']) def handle_text(message):     if not dialogue_manager.handle_message(message): # Если диалога нет, то отправляем приветствие         bot.send_message(message.chat.id, 'У тебя сейчас нет диалога. Напиши /start, чтобы начать.')   def pause_dialogue(dialogue):     bot.send_message(dialogue.user_id, 'Диалог приостановлен.')     bot.send_message(dialogue.get_context('partner'), 'Твой собеседник приостановил диалог.')   def continue_dialogue(dialogue):     bot.send_message(dialogue.user_id, 'Диалог продолжен.')     bot.send_message(dialogue.get_context('partner'), 'Твой собеседник продолжил диалог.')   if __name__ == '__main__':     bot.polling()

Вывод

По сути, это всё, с тонкостями разберетесь сами. Все 3 метода не идеальны и имеют свои плюсы и минусы: словарь быстро развернуть, но в нем легко запутаться при масштабировании, встроенные стейты выглядят красивее и понятнее, но всё ещё не имеют многих функций из коробки, telebot-dialogue имеет всё, что нужно при работе со сценариями, но очень громоздкий, из-за чего писать с ним маленькие приложения становится очень сложно, каждый имеет место быть, а вам желаю писать поменьше костылей и не писать как я. Спасибо за прочтение.