Develop Reference

I am trying to create a telegram bot, I am getting error in command handler it is for casual talk

Below is my telegram bot code.
I am trying to get input from user and return eventually I will give input to my ML model:
def chat(s):
return s
def handle_message(update: Update, context: CallbackContext):
print("inside")
tx = update.message.text
re = chat(tx)
update.message.reply_text(re)
def main():
updater = Updater("API_KEY",use_context=True)
dp = updater.dispatcher
dp.add_handler(CommandHandler(Filters.text,handle_message))
dp.add_error_handler(error)
updater.start_polling()
updater.idle()
Here is the error I am getting:
File "C:\Users\NAMIT\AppData\Local\Programs\Python\Python39\lib\site- packages\telegram\ext\commandhandler.py", line 161, in __init__
self.command = [x.lower() for x in command]
TypeError: '_Text' object is not iterable

You have to use MessageHandler instead of CommandHandler
#dp.add_handler(CommandHandler(Filters.text, handle_message))
dp.add_handler(MessageHandler(Filters.text, handle_message))
Minimal working code:
import os
import logging
from telegram.ext import Updater, MessageHandler, CommandHandler, Filters
TOKEN = os.getenv('TELEGRAM_TOKEN')
def error(update, context):
logger.warning('Update "%s" caused error "%s"', update, context.error)
def chat(s):
return s
def handle_message(update, context):
print("inside")
tx = update.message.text
re = chat(tx)
update.message.reply_text(re)
def main():
updater = Updater(token=TOKEN, use_context=True)
dp = updater.dispatcher
#dp.add_handler(CommandHandler(Filters.text, handle_message))
dp.add_handler(MessageHandler(Filters.text, handle_message))
dp.add_error_handler(error)
updater.start_polling()
updater.idle()
main()

How Can I add URL for Inlinekeyboard in Telegram Bot

I want to create a button that when I click on it will send the file to me in the telegram.
from config import TOKEN
from telegram import MessageEntity, ReplyKeyboardMarkup, Update
from telegram import InlineKeyboardButton, InlineKeyboardMarkup
from telegram.ext import Updater
from telegram.ext import CallbackContext
from telegram.ext import CommandHandler
from telegram.ext import MessageHandler, Filters
from telegram.ext import CallbackQueryHandler
import logging
import urllib.request , json
updater = Updater(token= TOKEN, use_context= True)
dispathcer = updater.dispatcher
logging.basicConfig(format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
level=logging.INFO)
download_url_link = 'https://saavn.me/songs?link='
home_page = 'https://saavn.me/home'
def readjson(url):
req = urllib.request.urlopen(url)
return json.loads(req.read().decode())
def start(update: Update, context: CallbackContext):
text= "Welcome #{username}".format(username = update.effective_user.username)
update.message.reply_text(text)
def download(update: Update, context: CallbackContext):
x = update.message.parse_entities(types = MessageEntity.URL)
msg = update.message.reply_text("Working on it...")
for i in x:
try:
rjson = read_json(end_point_link + x[i])
name = rjson["results"]['name']
download_link = rjson["results"]["downloadUrl"][4]["link"]
quality = rjson["results"]["downloadUrl"][4]["quality"]
msg.delete()
dl = update.message.reply_document(download_link, caption="Here is {} and quality is {}".format(name, quality))
keyboard = [
[
InlineKeyboardButton('128KB', callback_data=dl),
InlineKeyboardButton('320kb', callback_data=dl),
]
]
reply_markup = InlineKeyboardMarkup(keyboard)
update.message.reply_text("Please choose:",
reply_markup=reply_markup)
except:
continue
if 'error' in rjson:
continue
return
msg.edit_text("I can't fetch from that url. try again!")
dont work inlinekeyboard and just send for me link download and dont show my buttons
start_handler = CommandHandler('start', start)
download_hundler = MessageHandler(Filters.entity(MessageEntity.URL), download)
button_handler = CallbackQueryHandler(button)
dispathcer.add_handler(start_handler)
dispathcer.add_handler(download_hundler)
dispathcer.add_handler(button_handler)
updater.start_polling()
I run the program and the file is sent to me but it does not ask me 128 or 320 and it automatically sends the file why?

In the keyboard section, you should have a unique callback data for each button. for example:
keyboard = [
[
InlineKeyboardButton('128KB', callback_data='dl-128'),
InlineKeyboardButton('320kb', callback_data='dl-320'),
]
]
Then you should create a function to handle callback query:
def button(update: Update, context: CallbackContext):
data = update.callback_query.data
quality = int(data.split('-')[1])
if quality == 128:
# send 128kb file
elif quality == 320:
# send 320kb file
after that, you should create a callback handler with your preferred pattern. For this example it would be:
button_handler = CallbackQueryHandler(button, pattern='dl-')
dispathcer.add_handler(button_handler)

How to delay aiogram command?

I have inline buttons with a response to them, some people spam them, I would like to make a delay for the command.
How to implement this?
If possible, write another way to answer the user that the command can be written after a while
#dp.callback_query_handler(id, text='Правила ⚔️')
#dp.callback_query_handler(id, text='Мануалы 🧸')
async def inline_kb_answer_callback_handler(query: types.CallbackQuery):
answer_data = query.data
# always answer callback queries, even if you have nothing to say
await query.answer(f'Вы выбрали пункт {answer_data!r}')
if answer_data == 'Помощь 🧞':
text = "Есть какие-то вопросы? 🛎\n \nПо вопросам внутри чата:\n \n Сотрудничество - #reimannlive 🈺 \n \nПо всем вопросам: #FollHash ☯️\nПо всем вопросам, заявкам в тиму: #t3sse ☯️\n \nВот полезные команды, для развлекухи:\n \n/cat - киски 😏\n/dog - собачки 🦮\n/music - музычка 🌆\n/robot - бредовый видосик 🤣"
elif answer_data == 'Правила ⚔️':
text = """Пᴩᴀʙиᴧᴀ чᴀᴛᴀ 💻
=======================
Зᴀᴨᴩᴇщᴇнᴏ: 🚫
- ᴧюбᴀя ᴋᴏʍʍᴇᴩция ʙ чᴀᴛᴇ (ᴨᴏᴋуᴨᴋᴀ/ᴨᴩᴏдᴀжᴀ)
- уᴋᴀɜыʙᴀᴛь иᴧи ᴨᴏʍᴇчᴀᴛь дᴩуᴦиᴇ ᴋᴀнᴀᴧы иᴧи бᴏᴛы
- ᴩᴇᴋᴧᴀʍᴀ иᴧи уᴨᴏʍинᴀниᴇ ᴨᴏхᴏжих ᴩᴇᴄуᴩᴄᴏʙ/ɯᴏᴨᴏʙ/нᴇйʍᴏʙ ʙ ᴧюбᴏʍ ᴋᴏнᴛᴇᴋᴄᴛᴇ
- ᴨᴏᴨᴩᴏɯᴀйничᴇᴄᴛʙᴏ
- ɜᴧᴏуᴨᴏᴛᴩᴇбᴧᴇниᴇ "CAPS LOCK"
- ʙᴇᴄᴛи ᴄᴇбя нᴇᴀдᴇᴋʙᴀᴛнᴏ ʙ чᴀᴛᴇ и ᴩᴀɜʙᴏдиᴛь "ᴄᴩᴀч"
- ᴏᴄᴋᴏᴩбᴧᴇниᴇ "мᴏдᴇᴩᴀции/ᴨᴩᴏᴇᴋᴛᴀ/ɯᴏᴨᴀ" - бᴀн ❗️
- ᴏᴛᴨᴩᴀʙᴧяᴛь ᴄᴋᴩиʍᴇᴩы, ᴩᴀᴄчᴧᴇнᴇнᴋу, ᴄʙᴀᴄᴛиᴋу, нᴀциɜʍ, ᴋᴏнᴛᴇнᴛ 🔞
- ᴏɸᴏᴩʍᴧяᴛь ᴩᴀɜᴧичныᴇ ᴋᴀᴩᴛы, ᴀбуɜиᴛь ᴩᴇɸᴇᴩᴀᴧьную ᴄиᴄᴛᴇʍу, ᴄᴋᴀʍ и ᴏбʍᴀн ᴨᴏᴧьɜᴏʙᴀᴛᴇᴧᴇй
- ᴨᴩᴏᴨᴀᴦᴀндᴀ ᴨᴏᴧиᴛиᴋи
- ɸᴧуд\ᴄᴨᴀʍ ᴏдинᴀᴋᴏʙыʍи ɜᴀ ᴋᴏнᴛᴇᴋᴄᴛᴏʍ ᴄᴧᴏʙᴀʍи иᴧи ᴨᴩᴇдᴧᴏжᴇнияʍи (1 ᴨᴩᴇдуᴨᴩᴇждᴇниᴇ, ᴨᴏᴄᴧᴇ - ɯᴛᴩᴀɸ) """
elif answer_data == 'Мануалы 🧸':
text = "Краткий мануал о том как обрабатывать логи - https://telegra.ph/Kak-obrabatyvat-logi-05-30\nЗа привлечение новой аудитории, выдаю логи🥳"
else:
text = f'Unexpected callback data {answer_data!r}!'
await bot.send_message(ID, text)
if __name__ == '__main__':
executor.start_polling(dp, skip_updates=True)
I hope you can help me, thanks in advance!

aiogram has a flood avoidance (anti flood) example, which basically prevents users from misusing the command. remember to install (aiohttp, aioredis and redis) on your server.
import asyncio
from aiogram import Bot, Dispatcher, executor, types
from aiogram.contrib.fsm_storage.redis import RedisStorage2
from aiogram.dispatcher import DEFAULT_RATE_LIMIT
from aiogram.dispatcher.handler import CancelHandler, current_handler
from aiogram.dispatcher.middlewares import BaseMiddleware
from aiogram.utils.exceptions import Throttled
TOKEN = 'BOT_TOKEN_HERE'
# In this example Redis storage is used
storage = RedisStorage2(db=5)
bot = Bot(token=TOKEN)
dp = Dispatcher(bot, storage=storage)
def rate_limit(limit: int, key=None):
"""
Decorator for configuring rate limit and key in different functions.
:param limit:
:param key:
:return:
"""
def decorator(func):
setattr(func, 'throttling_rate_limit', limit)
if key:
setattr(func, 'throttling_key', key)
return func
return decorator
class ThrottlingMiddleware(BaseMiddleware):
"""
Simple middleware
"""
def __init__(self, limit=DEFAULT_RATE_LIMIT, key_prefix='antiflood_'):
self.rate_limit = limit
self.prefix = key_prefix
super(ThrottlingMiddleware, self).__init__()
async def on_process_message(self, message: types.Message, data: dict):
"""
This handler is called when dispatcher receives a message
:param message:
"""
# Get current handler
handler = current_handler.get()
# Get dispatcher from context
dispatcher = Dispatcher.get_current()
# If handler was configured, get rate limit and key from handler
if handler:
limit = getattr(handler, 'throttling_rate_limit', self.rate_limit)
key = getattr(handler, 'throttling_key', f"{self.prefix}_{handler.__name__}")
else:
limit = self.rate_limit
key = f"{self.prefix}_message"
# Use Dispatcher.throttle method.
try:
await dispatcher.throttle(key, rate=limit)
except Throttled as t:
# Execute action
await self.message_throttled(message, t)
# Cancel current handler
raise CancelHandler()
async def message_throttled(self, message: types.Message, throttled: Throttled):
"""
Notify user only on first exceed and notify about unlocking only on last exceed
:param message:
:param throttled:
"""
handler = current_handler.get()
dispatcher = Dispatcher.get_current()
if handler:
key = getattr(handler, 'throttling_key', f"{self.prefix}_{handler.__name__}")
else:
key = f"{self.prefix}_message"
# Calculate how many time is left till the block ends
delta = throttled.rate - throttled.delta
# Prevent flooding
if throttled.exceeded_count <= 2:
await message.reply('Too many requests! ')
# Sleep.
await asyncio.sleep(delta)
# Check lock status
thr = await dispatcher.check_key(key)
# If current message is not last with current key - do not send message
if thr.exceeded_count == throttled.exceeded_count:
await message.reply('Unlocked.')
#dp.message_handler(commands=['start'])
#rate_limit(5, 'start') # this is not required but you can configure throttling manager for current handler using it
async def cmd_test(message: types.Message):
# You can use this command every 5 seconds
await message.reply('Test passed! You can use this command every 5 seconds.')
if __name__ == '__main__':
# Setup middleware
dp.middleware.setup(ThrottlingMiddleware())
# Start long-polling
executor.start_polling(dp)

How to run separate instances of a Python Telegram Bot?

Currently, I have created a Python bot with buttons that can be pressed to add orders to a list of orders, as shown below:
Sample of the Telebot's Buttons and the List
My bot is in separate chat groups, Chat 1 and Chat 2. When I press a button to add the order in Chat 1, the order is also added in Chat 2.
How do I separate the instances of the bot such that adding orders in Chat 1 does not affect the order list of Chat 2?
Code for the data:
def button(update: Update, _: CallbackContext) -> None:
query = update.callback_query
query.answer()
result = ""
keyboard = []
if str(query.data) == 'macs':
keyboard = [
[InlineKeyboardButton("Filet o Fish", callback_data='fof')],
[InlineKeyboardButton("Big Mac", callback_data='bm')],
[InlineKeyboardButton("Back", callback_data='back')]
]
elif str(query.data) in ('ameens', 'Maggi Pattaya', 'Garlic Naan'):
keyboard = [
[InlineKeyboardButton("Maggi Pattaya", callback_data='Maggi Pattaya')],
[InlineKeyboardButton("Garlic Naan", callback_data='Garlic Naan')],
[InlineKeyboardButton("Back", callback_data='back')]
]
if str(query.data) in ('Maggi Pattaya', 'Garlic Naan'):
order_list.append(str(query.data))
for order in order_list:
result += '\n' + order
elif str(query.data) == 'back':
keyboard = [
[InlineKeyboardButton("Ameen's", callback_data='ameens')],
[InlineKeyboardButton("Macs", callback_data='macs')]
]
if len(order_list) != 0:
for order in order_list:
result += '\n' + order
else:
order_list.append(str(query.data))
for order in order_list:
result += order
reply_markup = InlineKeyboardMarkup(keyboard)
if str(query.data) == 'back':
query.edit_message_text(text="Where would you like to order from?", reply_markup = reply_markup)
else:
#query.edit_message_text(text=f"Menu from {query.data}", reply_markup = reply_markup)
query.edit_message_text(text=f"Orders: {result}", reply_markup = reply_markup)

The general problem is that you store things in order_list which appears to be some kind of global variable. Vad Sims answer already gives the important hint that you should store data on a per chat basis to distinguish between data stored for chat 1 and data stored for chat 2. As you're using the python-telegram-bot library, I suggest to use the built-in feature context.chat_data. Please have a look at this wiki page for more details.
Disclaimer: I'm currently the maintainer of python-telgeram-bot.

You can use this code:
#!/usr/bin/env python
# pylint: disable=C0116
# This program is dedicated to the public domain under the CC0 license.
"""
Basic example for a bot that uses inline keyboards. For an in-depth explanation, check out
https://git.io/JOmFw.
"""
import logging
from telegram import InlineKeyboardButton, InlineKeyboardMarkup, Update
from telegram.ext import Updater, CommandHandler, CallbackQueryHandler, CallbackContext
logging.basicConfig(
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', level=logging.INFO
)
logger = logging.getLogger(__name__)
chats = {}
def start(update: Update, _: CallbackContext) -> None:
if update.message.chat.id not in chats:
chats[update.message.chat.id] = []
keyboard = [
[
InlineKeyboardButton("Option 1", callback_data='1'),
InlineKeyboardButton("Option 2", callback_data='2'),
],
[InlineKeyboardButton("Option 3", callback_data='3')],
]
reply_markup = InlineKeyboardMarkup(keyboard)
txt = ''.join(chats[update.message.chat.id])
update.message.reply_text(txt, reply_markup=reply_markup)
def button(update: Update, _: CallbackContext) -> None:
query = update.callback_query
# CallbackQueries need to be answered, even if no notification to the user is needed
# Some clients may have trouble otherwise. See https://core.telegram.org/bots/api#callbackquery
query.answer()
if query.from_user.id not in chats:
chats[query.from_user.id] = []
chats[query.chat.id].append(query.data)
query.edit_message_text(text=f"Selected option: {query.data}")
def help_command(update: Update, _: CallbackContext) -> None:
update.message.reply_text("Use /start to test this bot.")
def main() -> None:
# Create the Updater and pass it your bot's token.
updater = Updater("TOKEN")
updater.dispatcher.add_handler(CommandHandler('start', start))
updater.dispatcher.add_handler(CallbackQueryHandler(button))
updater.dispatcher.add_handler(CommandHandler('help', help_command))
# Start the Bot
updater.start_polling()
# Run the bot until the user presses Ctrl-C or the process receives SIGINT,
# SIGTERM or SIGABRT
updater.idle()
if __name__ == '__main__':
main()

How to loop in python Telegram bot conversation handler

bot doesn't come back to the start message after running once.
import logging
from config import TOKEN, hello_msg, key1_msg
import mysql.connector
from telegram.ext import Filters, ConversationHandler, CommandHandler, MessageHandler,
Filters, Updater, InlineQueryHandler, CallbackQueryHandler, CallbackContext
from telegram import InlineQueryResultArticle, InputTextMessageContent,
InlineKeyboardButton, InlineKeyboardMarkup, Update
CHOOSING, CHOOSING2 = range(2)
keyboard1 = [
[InlineKeyboardButton("Welcome Message", callback_data = 'welcome_Message')],
[InlineKeyboardButton("Commands", callback_data = 'Commands')],
[InlineKeyboardButton("Links to our website", callback_data = 'links_to_our_websites')],
[InlineKeyboardButton("Demo Try", callback_data = 'Demo_try')],
[InlineKeyboardButton("register", callback_data = 'register')],
[InlineKeyboardButton("Contact us", callback_data = 'Contact_us')]
]
def start(update: Update, context: CallbackContext):
global up, cal
up = update
cal = CallbackContext
context.bot.send_message(chat_id = update.effective_chat.id, text = hello_msg)
reply_markup = InlineKeyboardMarkup(keyboard1)
update.message.reply_text("please Choose: ", reply_markup = reply_markup)
return CHOOSING
def button1(update: Update, context: CallbackContext):
query = update.callback_query
query.answer()
answer = query.data
context.bot.send_message(chat_id = update.effective_chat.id, text = key1_msg[answer])
return CHOOSING
def main():
updater = Updater(TOKEN, use_context=True)
dp = updater.dispatcher
new = ConversationHandler(entry_points = [CommandHandler("start", start)], states = {CHOOSING : [MessageHandler(Filters.regex('^(Welcome Message|Commands|Links to our website|Demo Try|register|Contact us)$'), start)]},fallbacks=[MessageHandler(Filters.regex('^start$'), sart)])
dp.add_handler(new)
dp.add_handler(CallbackQueryHandler(button1))
updater.start_polling()
updater.idle()
if __name__ == "__main__":
main()
I want to run the start command again right after a user will choose an option from a button...
I wanna learn how to pass parameters when giving handlers inside the conversation handler.
thank you.