handler error

[Sivarius]

Hi there!
Using that in docker on Synology NAS
Everything work fine unless quality selection
So whenever i click on "add to library" and got list of quality the bos is died.

Heres error log from container

/usr/local/lib/python3.11/site-packages/telegram/ext/_handlers/conversationhandler.py:889: PTBUserWarning: 'handle_selection' returned state 3 which is unknown to the ConversationHandler start_conversation.

self._update_state(new_state, conversation_key, handler)

[BoKKeR]

Having the same error

[Sivarius]

Having the same error

I guess it's because its not correctly translated, problem should be gone in en languade mode

[BlatantPlatypus]

Having the same issue, but I have changed the language back to en-us and it's still there.

Have you found a solution to this?

It seems to be almost at random, but failing more often than not.

[dylannykolyszyn]

Replace your start.py with this:

"""
Filename: start.py
Author: Christian Blank (https://github.com/Cyneric)
Created Date: 2024-11-08
Description: Start handler module.

This module handles the main entry point and menu for the bot.
"""

from telegram import Update, InlineKeyboardButton, InlineKeyboardMarkup
from telegram.ext import (
    CommandHandler,
    ContextTypes,
    CallbackQueryHandler,
    ConversationHandler,
    MessageHandler,
    filters
)
from colorama import Fore

from src.utils.logger import get_logger, log_user_interaction
from src.bot.handlers.auth import require_auth
from src.bot.handlers.media import MediaHandler, SEARCHING, SELECTING, QUALITY_SELECT, SEASON_SELECT
from src.bot.handlers.help import HelpHandler
from src.bot.keyboards import get_main_menu_keyboard
from src.services.translation import TranslationService

logger = get_logger("addarr.start")
logger.info("Start handler module initialized")

class StartHandler:
    """Handler for start command and main menu"""
    
    def __init__(self):
        self.media_handler = MediaHandler()
        self.help_handler = HelpHandler()
        self.translation = TranslationService()
    
    def get_handler(self):
        """Get the command handlers"""
        MENU_STATE = 1  # Add a state for menu interactions
        
        return [
            ConversationHandler(
                entry_points=[CommandHandler("start", self.show_menu)],
                states={
                    MENU_STATE: [
                        CallbackQueryHandler(self.handle_menu_selection, pattern="^menu_"),
                    ],
                    SEARCHING: [
                        MessageHandler(
                            filters.TEXT & ~filters.COMMAND,
                            self.media_handler.handle_search
                        ),
                        CallbackQueryHandler(self.handle_menu_selection, pattern="^menu_")
                    ],
                    SELECTING: [
                        CallbackQueryHandler(
                            self.media_handler.handle_selection,
                            pattern="^select_"
                        ),
                        CallbackQueryHandler(
                            self.media_handler.handle_navigation,
                            pattern="^nav_"
                        ),
                        CallbackQueryHandler(
                            self.handle_menu_selection,
                            pattern="^menu_"
                        )
                    ],
                    QUALITY_SELECT: [
                        CallbackQueryHandler(
                            self.media_handler.handle_quality_selection,
                            pattern="^quality_"
                        ),
                        CallbackQueryHandler(
                            self.handle_menu_selection,
                            pattern="^menu_"
                        )
                    ],
                    SEASON_SELECT: [
                        CallbackQueryHandler(
                            self.media_handler.handle_season_selection,
                            pattern="^season_"
                        ),
                        CallbackQueryHandler(
                            self.media_handler.handle_season_confirm,
                            pattern="^season_confirm$"
                        ),
                        CallbackQueryHandler(
                            self.handle_menu_selection,
                            pattern="^menu_"
                        )
                    ]
                },
                fallbacks=[
                    CommandHandler("cancel", self.media_handler.cancel_search),
                ],
                name="start_conversation",
                persistent=False
            )
        ]
    
    @require_auth
    async def show_menu(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
        """Show the main menu"""
        log_user_interaction(logger, update.effective_user, "/start")

        welcome_text = self.translation.get_text("mainMenu")
        
        if update.callback_query:
            # Handle callback query
            query = update.callback_query
            await query.answer()
            await query.message.edit_text(
                welcome_text,
                reply_markup=get_main_menu_keyboard()
            )
        elif update.effective_message:
            # Handle direct command
            await update.effective_message.reply_text(
                welcome_text,
                reply_markup=get_main_menu_keyboard()
            )
        
        return 1  # Return MENU_STATE to enter the menu state
    
    @require_auth
    async def handle_menu_selection(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
        """Handle menu button selections"""
        logger.info("handle_menu_selection called")
        
        if not update.callback_query:
            logger.warning("Received menu selection without callback query")
            return
            
        query = update.callback_query
        logger.info(f"Received callback query with data: {query.data}")
        
        await query.answer()
        
        action = query.data.replace("menu_", "")
        user = query.from_user
        
        logger.info(f"Menu button pressed - Action: {action}, User: {user.first_name} (ID: {user.id})")
        log_user_interaction(logger, user, f"menu_{action}")
        
        if action == "back":
            logger.info(f"Back to menu requested by user {user.first_name} (ID: {user.id})")
            await self.show_menu(update, context)
            return
            
        if action == "cancel":
            logger.info(f"Cancel action triggered by user {user.first_name} (ID: {user.id})")
            if context.user_data:
                context.user_data.clear()
            await query.message.edit_text(
                self.translation.get_text("Canceled")
            )
            return ConversationHandler.END
            
        if action in ["movie", "series", "music"]:
            logger.info(f"Search initiated for {action} by user {user.first_name} (ID: {user.id})")
            # Set search type in context
            context.user_data["search_type"] = action
            
            # Get translated prompt based on media type
            prompts = {
                "movie": self.translation.get_text("Title", subject="Movie"),
                "series": self.translation.get_text("Title", subject="Series"),
                "music": self.translation.get_text("Title", subject="Music")
            }
            
            # Create keyboard with cancel button
            keyboard = [
                [InlineKeyboardButton(
                    f"❌ {self.translation.get_text('Cancel')}", 
                    callback_data="menu_cancel"
                )]
            ]
            reply_markup = InlineKeyboardMarkup(keyboard)
            
            await query.message.edit_text(
                prompts[action],
                reply_markup=reply_markup
            )
            
            return SEARCHING
            
        # For commands that end the conversation
        if action in ["status", "help", "settings", "delete"]:
            if action == "status":
                await self.media_handler.handle_status(update, context)
            elif action == "help":
                await self.help_handler.show_help(update, context)
            elif action == "settings":
                await self.media_handler.handle_settings(update, context)
            elif action == "delete":
                delete_text = self.translation.get_text("messages.DeletePrompt")
                await query.message.edit_text(delete_text)
            return ConversationHandler.END
            
        logger.warning(f"Unknown menu action '{action}' from user {user.first_name} (ID: {user.id})")
        return ConversationHandler.END
    
    async def start_movie_search(self, query):
        """Start movie search conversation"""
        await query.message.edit_text(
            "🎬 Please enter the name of the movie you want to search for:\n"
            "(Use /cancel to cancel)"
        )
        # Set conversation state for movie search
        
    # ... (similar methods for other menu options) 

It was missing the QUALITY_SELECT and SEASON_SELECT handlers.