Version 20.1 - Nested Conversation - Back Button - Not Working

[bhadresh-dahanuwala]

Hi,

I am trying to implement nested conversation. I have 2 back buttons. The first one is working and the second is not. I am not not sure if I have implemented the first back button correctly, even though it is working fine.

Steps:

1. Submit /start command
2. Choose any option 100 or 101
3. Click Back button (it works, but please check the implementation)
4. If you clicked the back button then you should be in the top menu. So again choose either 100 or 101
5. Click Show Info
6. Click back button (Not working)

I am having tough time understanding the nested conversation flow. There is no tutorial video available for version 20.1

Request you to please help me implement both the back buttons in a proper way.

Here is the code

import os
import logging

from telegram import (
    Update,
    InlineKeyboardButton,
    InlineKeyboardMarkup
)
from telegram.ext import (
    Application,
    CommandHandler,
    ContextTypes,
    ConversationHandler,
    CallbackContext,
    CallbackQueryHandler
)

from sddmm_constants import *

# States top Level
SELECTING_FAMILY = map(chr, range(1))

# States second level
SELECTING_ACTION = map(chr, range(1, 2))

# States third level
SHOWING_INFO, ADDING_ADDRESS, ADDING_MEMBER, EDITING_ADDRESS, EDITING_MEMBER = map(str, range(2, 7))

# States fourth level
SELECTING_MEMBER = map(str, range(7, 8))

# States meta
SUBMIT_ADDRESS_INFO, SUBMIT_MEMBER_INFO = map(str, range(8, 10))

# Stop Nested
STOPPING = map(str, range(10, 11))

# End
END = ConversationHandler.END

class Data:
    
    def __init__(self) -> None:
        logging.basicConfig(format="%(asctime)s - %(name)s - %(levelname)s - %(message)s", encoding='utf-8', level=logging.INFO)
        self.load_telegram_app()

    def load_telegram_app(self):
        app = Application.builder().token(os.getenv("TELE_TEST_API")).build()
        show_info_conv = ConversationHandler(
            entry_points=[CallbackQueryHandler(self.select_member, pattern=f"^{str(SHOWING_INFO)}$")],
            states={
                SELECTING_MEMBER: [CallbackQueryHandler(self.show_member_info, pattern="^fam-mem")]
            },
            fallbacks=[
                CallbackQueryHandler(self.end_show_info_level, pattern=f"^{str(END)}$"),
                CommandHandler("stop", self.stop_nested)
            ],
            map_to_parent={
                END: SELECTING_FAMILY,
                STOPPING: END
            }
        )
        selecting_handlers = [
            show_info_conv,
            CallbackQueryHandler(self.end_show_info_level, pattern=f"^{str(END)}$")
            #CallbackQueryHandler(self.end, pattern="^" + str(END) + "$")
        ]
        conv_handler = ConversationHandler(
            entry_points=[CommandHandler("start", self.start)],
            states={
                SELECTING_FAMILY: [CallbackQueryHandler(self.select_family, pattern="^sel-fam-")],
                SELECTING_ACTION: selecting_handlers,
                SELECTING_MEMBER: selecting_handlers,
                STOPPING: [CommandHandler("start", self.start)]
            },
            fallbacks=[
                CommandHandler("stop", self.stop)
            ]
        )
        app.add_handler(conv_handler)
        app.run_polling(5)

    async def start(self, update: Update, context: CallbackContext) -> int:
        user_id = update.effective_user.id
        logging.info(f"start: [user-id] {user_id}")
        txt = "Please select family ID"
        buttons = [
            [InlineKeyboardButton("100", callback_data="sel-fam-100")],
            [InlineKeyboardButton("101", callback_data="sel-fam-101")]
        ]
        markup = InlineKeyboardMarkup(buttons)
        await update.effective_message.reply_text(text=txt, reply_markup=markup)
        #await update.message.reply_text(text=txt, reply_markup=markup)
        return SELECTING_FAMILY
    
    async def stop(self, update: Update, context: CallbackContext) -> int:
        logging.info(f"stop: [user-id] {update.message.from_user.id}")
        await update.message.reply_text("Okay, bye.")
        return END

    async def stop_nested(update: Update, context: ContextTypes.DEFAULT_TYPE) -> str:
        logging.info(f"stop_nested: [user-id] {update.callback_query.from_user.id}")
        await update.message.reply_text("Thank you!")
        return STOPPING

    async def end_show_info_level(self, update: Update, context: CallbackContext) -> int:
        logging.info(f"end_show_info_level: [user-id] {update.callback_query.from_user.id}")
        await self.start(update, context)
        return END

    async def select_family(self, update: Update, context: CallbackContext) -> int:
        family_id = int(update.callback_query.data.replace("sel-fam-", ""))
        context.user_data["family-id"] = family_id
        logging.info(f"select_family: [user-id] {update.callback_query.from_user.id} [family-id] {family_id}")
        return await self.select_action(update, context)
    
    async def select_member(self, update: Update, context: CallbackContext) -> int:
        logging.info(f"select_member:")
        markup = InlineKeyboardMarkup([[InlineKeyboardButton("Member-1", callback_data="fam-mem")]])
        await update.effective_message.reply_text("Please select member", reply_markup=markup)
        return SELECTING_MEMBER

    async def select_action(self, update: Update, context: CallbackContext) -> int:
        logging.info(f"select_action: [user-id] {update.callback_query.from_user.id} [family-id] {context.user_data['family-id']}")
        buttons = [
            [InlineKeyboardButton("Show Info", callback_data=str(SHOWING_INFO))],
            [InlineKeyboardButton("Back", callback_data=str(END))]
        ]
        markup = InlineKeyboardMarkup(buttons)
        await update.callback_query.message.reply_text(text="Please select an action", reply_markup=markup)
        return SELECTING_ACTION
    
    async def show_member_info(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> int:
        logging.info(f"show_member_info:")
        markup = InlineKeyboardMarkup([[InlineKeyboardButton("Back", callback_data=str(END))]])
        await update.effective_message.reply_text("Please choose an action", reply_markup=markup)
        return END
    
    async def end(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> int:
        logging.info(f"end: ")
        return END

data = Data()