I’m building a Telegram bot using Python and running into issues with handling multiple users at once. The main problem happens when my bot asks a question to one user and waits for their reply, but then another user sends a message or starts a conversation before the first person answers.
From what I understand about how Telegram’s bot API works, there’s an offset parameter that you send when getting updates. Any update with an ID lower than this offset gets marked as processed and removed from the queue. This means if I process update number 5, all previous updates (1, 2, 3, 4) also get deleted automatically.
What would be the most effective and clean approach in Python to manage these overlapping conversations where different users might be at different stages of interaction with the bot?
u def want to use async/await for this! each user shud have their own coroutine so things dont block. i recommend using a dict to keep track of user states with their user_id as the key. this way, it’s easier to manage where everyone is during their chats.
I’ve hit this exact problem building a customer service bot. You need a state machine pattern with session management. Store each user’s conversation state in a database or Redis cache - use their Telegram user ID as the key. I built a conversation handler that keeps separate context for each user. When an update comes in, check which user sent it, grab their current state, then process the message. This stops users from messing with each other’s conversations. Don’t worry about the offset parameter - you’re processing updates sequentially anyway. Just make sure your app logic treats each user independently instead of trying to maintain some global conversation state.
Threading module works great for this. Spawn a separate thread for each user interaction when your bot gets an update - they won’t interfere with each other. I use a global dictionary where threads store and grab user-specific data by user ID. You can handle blocking operations like waiting for input without freezing the whole bot. Just use proper locking when threads access shared resources. Way simpler than full async patterns, especially for sequential Q&A flows where users complete steps in order.