arbitrary_callback_data tries to match some UUID to the CallbackQueryHandler's pattern

[AusiasMarch]

I'm quite new to the python-telegram-bot, so I might be missing something.

When trying to send a longer than 64 bytes callback_data using arbitrary_callback_data, the string used to match the CallbackQueryHandler's pattern looks more like and UUID and has no relation to with the original content. This makes it impossible to match it.

Moreover, when trying to match it against the values stored in the telegram.ext.CallbackDataCache._keyboard_data it does not match any of them.

How can I recover the original calback_data and route it to the proper handler?

edit:

Minimal working example:

import telegram
from telegram import InlineKeyboardButton, InlineKeyboardMarkup
from telegram.ext import CallbackContext, CallbackQueryHandler, Updater

from config import settings


def process_callback(callback):
    pass


def filter_callback(uuid):
    print(f"Recieved uuid: {uuid}")
    for k, v in bot_cache._keyboard_data.items():
        print(f"key: {k}")
        print(f"keyboard_uuid: {v.keyboard_uuid}")
        print(f"button_Data: {v.button_data}")


bot = telegram.ext.ExtBot(settings.TELEGRAM_API_TOKEN, arbitrary_callback_data=True)
bot_cache = telegram.ext.CallbackDataCache(bot)

keyboard = [[InlineKeyboardButton("Long callback", callback_data="X" * 256)]]
reply_markup = InlineKeyboardMarkup(keyboard)
reply_markup_arbitrary = bot_cache.process_keyboard(reply_markup)

updater = Updater(settings.TELEGRAM_API_TOKEN, use_context=True)
dp = updater.dispatcher

dp.add_handler(CallbackQueryHandler(process_callback, pattern=filter_callback))

bot.send_message(
    text="This has a long callback",
    chat_id=settings.CHAT_ID,
    reply_markup=reply_markup_arbitrary,
)

updater.start_polling()
updater.idle()

When clicking in the keyboard button, the output is:

Recieved uuid: cc0963c98e974970ba211e4bcd781b644154f950e6bb4c5b848fc6ed48f8aefc
key: 1d490a2c8ed04736aca72385d097d991
keyboard_uuid: 1d490a2c8ed04736aca72385d097d991
button_Data: {'5536d6b795074e6a9c24d0ab14023159': 'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'}

[Bibo-Joshi]

Hi. CallbackDataCache should usually not be instantiated manually and process_keyboard should not be called manually. This is done automatically by ptb. Please have a careful look at the wiki page and the example.

[AusiasMarch]

You were both right (I can't mark both as answer). I had managed to hack my way into make it work and came to post the new version. Both your comments allowed me to make it way cleaner.

[Poolitzer]

The actual issue though, if I see it correctly, that you use Updater() without setting arbitrary_callback_data to True or passing your created bot instance, thus the dispatcher/updater cant resolve the arbitrary_callback_data passed by the other ExtBot instance properly and you receive the uuid in your filter instead of the long x string you expect.

[Bibo-Joshi]

the bot doesn't even use the bot_cache though, so passing the bot to the updater wouldn't fix the problem :)

[AusiasMarch]

Leaving here the final working version thanks to both @Bibo-Joshi and @Poolitzer:

import telegram
from telegram import InlineKeyboardButton, InlineKeyboardMarkup, Update
from telegram.ext import CallbackContext, CallbackQueryHandler, Updater

from config import settings


def do_a(update: Update, context: CallbackContext):
    callback_data = update.callback_query.data
    update.callback_query.edit_message_reply_markup(reply_markup=None)
    bot.send_message(
        text=f"Doing A{callback_data['c']}",
        chat_id=update.callback_query.message.chat_id,
    )


def ask_a(update: Update, context: CallbackContext):
    callback_data = update.callback_query.data
    keyboard = [
        [InlineKeyboardButton("Do a1", callback_data=dict(**callback_data, c=1))],
        [InlineKeyboardButton("Do a2", callback_data=dict(**callback_data, c=2))],
        [InlineKeyboardButton("Do a3", callback_data=dict(**callback_data, c=3))],
    ]

    reply_markup = InlineKeyboardMarkup(keyboard)
    update.callback_query.edit_message_reply_markup(reply_markup=reply_markup)


def pattern_a(callback_data):
    return "c" in callback_data.keys()


def pattern_ask_a(callback_data):
    return "c" not in callback_data.keys()


bot = telegram.ext.ExtBot(settings.TELEGRAM_API_TOKEN, arbitrary_callback_data=True)

keyboard = [
    [InlineKeyboardButton("a1", callback_data=dict(a=1, b=2, c=1))],
    [InlineKeyboardButton("a?", callback_data=dict(a=1, b=2))],
]
reply_markup = InlineKeyboardMarkup(keyboard)

updater = Updater(bot=bot, use_context=True)
dp = updater.dispatcher

dp.add_handler(CallbackQueryHandler(do_a, pattern=pattern_a))
dp.add_handler(CallbackQueryHandler(ask_a, pattern=pattern_ask_a))

bot.send_message(
    text="These buttons have an arbitrary callback data.",
    chat_id=settings.CHAT_ID,
    reply_markup=reply_markup,
)

updater.start_polling()
updater.idle()

[Poolitzer]

This way you still have two bot instances, you can use the one from the updater (bot = updater.bot).

[AusiasMarch]

But with updater = Updater(bot=bot, use_context=True) ain't I reusing the first bot instance?

[Poolitzer]

oh wow I missed that, nevermind, yes you are all good.