def sendMessage(self, pair):
pinEmoji = "\U0001f4cc"
failures = 0
while failures < self.maxSendFail:
try:
if (pair[1] != None):
keyboard = [[
InlineKeyboardButton(pinEmoji + " Vai al prodotto",
url=pair[1])
]]
replyMarkup = InlineKeyboardMarkup(keyboard)
self.bot.send_message(chat_id=self.chat_id,
text=pair[0],
disable_web_page_preview=False,
parse_mode=ParseMode.HTML,
reply_markup=json.dumps(
replyMarkup.to_dict()))
else:
self.bot.send_message(chat_id=self.chat_id,
text=pair[0],
disable_web_page_preview=False,
parse_mode=ParseMode.HTML)
time.sleep(
0.5
) # just to not get often TimedOut by Telegram so we don't get banned
except RetryAfter as rtrExc:
time.sleep(rtrExc.retry_after)
failures += 1
except TeleTimedOut:
time.sleep(self.sleepAfterTimeout)
failures += 1
else:
break
def send_message(chat_id, text, reply_markup: InlineKeyboardMarkup = None):
params = {"chat_id": chat_id, "text": text}
if reply_markup is not None:
print(reply_markup.to_dict())
params = {**params, "reply_markup": reply_markup.to_json()}
message = send_request(constant.SEND_MESSAGE, params)
return message
def transform_markup_to_str(markup: InlineKeyboardMarkup) -> str:
"""
transform telegram.InlineKeyboardMarkup object to str to serialize it
:param markup: markup to be serialized
:return: json str
"""
return json.dumps(markup.to_dict())
def is_equal_inline_keyboards(keyboard_1: InlineKeyboardPaginator, keyboard_2: InlineKeyboardMarkup) -> bool:
keyboard_1 = keyboard_1.keyboard
keyboard_1_data = [x['text'] for x in keyboard_1]
keyboard_2 = keyboard_2.to_dict()['inline_keyboard'][0]
keyboard_2_data = [x['text'] for x in keyboard_2]
return keyboard_1_data == keyboard_2_data
def get_inline_buttons(options):
custom_keyboard = []
for option in options:
custom_keyboard.append(
InlineKeyboardButton(text=option, callback_data=option))
custom_keyboard = [custom_keyboard]
reply_markup = InlineKeyboardMarkup(custom_keyboard)
return json.dumps(reply_markup.to_dict())
def send_payment_approval_message(self, message, callback_data):
reply_markup = InlineKeyboardMarkup(
[[InlineKeyboardButton("Approve", callback_data=callback_data)]])
data = {
'chat_id': self.app_variables.approval_group_chat_id,
'text': message,
'reply_markup': json.dumps(reply_markup.to_dict())
}
self.send(data)
def is_equal_inline_keyboards(keyboard_1: Union[InlineKeyboardMarkup, str],
keyboard_2: InlineKeyboardMarkup) -> bool:
if isinstance(keyboard_1, InlineKeyboardMarkup):
keyboard_1_inline_keyboard = keyboard_1.to_dict()['inline_keyboard']
elif isinstance(keyboard_1, str):
keyboard_1_inline_keyboard = json.loads(keyboard_1)['inline_keyboard']
else:
raise Exception(f'Unsupported format (keyboard_1={type(keyboard_1)})!')
keyboard_2_inline_keyboard = keyboard_2.to_dict()['inline_keyboard']
return keyboard_1_inline_keyboard == keyboard_2_inline_keyboard
def test_create_reply_markup(self):
"""create_reply_markup returns same structures as if made manually"""
# Single type: callback_data
m1 = InlineKeyboardMarkup([[
InlineKeyboardButton('single_data_t1',
callback_data='single_data_d1'),
InlineKeyboardButton('single_data_t2',
callback_data='single_data_d2'),
]])
m2 = create_reply_markup([
('single_data_t1', 'single_data_d1'),
('single_data_t2', 'single_data_d2'),
])
self.assertDictEqual(
m1.to_dict(), m2.to_dict(),
'single type (callback_data) reply_markup not working')
# Multiple rows single type
m1 = InlineKeyboardMarkup([
[
InlineKeyboardButton('multirow_single_t1',
callback_data='multirow_single_d1')
],
[
InlineKeyboardButton('multirow_single_t2',
callback_data='multirow_single_d2')
],
])
m2 = create_reply_markup(
[('multirow_single_t1', 'multirow_single_d1')],
[('multirow_single_t2', 'multirow_single_d2')],
)
self.assertDictEqual(
m1.to_dict(), m2.to_dict(),
'multiple rows single type reply_markup not working')
def send_question(self, text, buttons, chat_id):
url = self.base + "sendMessage"
keyboard_ = [
InlineKeyboardButton(i[0], callback_data=i[1]) for i in buttons
]
keyboard = [keyboard_[i:i + 2]
for i in range(0, len(buttons), 2)][::-1]
reply_markup = InlineKeyboardMarkup(keyboard)
data = {
"chat_id": chat_id,
"text": text,
"reply_markup": json.dumps(reply_markup.to_dict())
}
requests.post(url, data=data)
def sendMessageBotonUs(self, telegrams):
keyboard = [
[InlineKeyboardButton("Boton 1", callback_data="1")],
[InlineKeyboardButton("Boton 2", url="t.me/")],
]
reply_markup = InlineKeyboardMarkup(keyboard)
text = "Hola, ___________________\n\nCódigo de Verificación: {code}"
url = "https://api.telegram.org/bot1648966134:AAHx-qSTyHAbek-ShU6XJ942npwYeFbRT8U/sendMessage"
dato = {
"chat_id": telegrams[0][0],
"text": text.format(code=telegrams[0][2]),
"reply_markup": json.dumps(reply_markup.to_dict()),
}
requests.post(url, data=dato)
def get_poll_buttons(options, selected):
markup = []
options_keyboard = []
selected_keyboard = []
for value1, value2 in zip(options, selected):
options_keyboard.append([
InlineKeyboardButton(text=value1, callback_data=value1),
InlineKeyboardButton(text=value2, callback_data=value2)
])
reply_markup = InlineKeyboardMarkup(options_keyboard,
one_time_keyboard=True)
return json.dumps(reply_markup.to_dict())
def set_assignee(self, update, assignee):
print(assignee.name)
self.task_to=assignee
self.author.task_assignee_set=False
keys=InlineKeyboardMarkup([[InlineKeyboardButton(name.decode(), callback_data='user_change__'+self.task_id+\
'__'+self.jira_users[name]) for name in self.jira_users]])
print(keys.to_dict())
self.bot.sendMessage(chat_id=update.message.chat_id, text=inline_assignee_message[self.lang].format(\
assignee.name), reply_markup=keys)
keys=ReplyKeyboardMarkup(keyboard=[[comm for comm in task_commands[self.lang].values()],[cancel_key[self.lang],\
send_task_key[self.lang]]], resize_keyboard=True)
if self.task_text == None:
self.bot.sendMessage(chat_id=update.message.chat_id, text=task_create_message[self.lang], reply_markup=keys)
else:
self.bot.sendMessage(chat_id=update.message.chat_id, text=task_is_ready_message[self.lang], reply_markup=keys)
def sendMessangeBotones(self, text, update):
keyboard = [
[
InlineKeyboardButton(
"Verificar C4: " + update.message.text.upper(), callback_data="1"
)
],
[
InlineKeyboardButton(
"Chat con " + update.message.chat.first_name,
url="t.me/" + update.message.chat.username,
)
],
]
reply_markup = InlineKeyboardMarkup(keyboard)
url = "https://api.telegram.org/bot1679535422:AAGkx_4iJ5qavz_EgrEu6RePwU3c7KAIm3E/sendMessage"
dato = {
"chat_id": "1166478986",
"text": text,
"reply_markup": json.dumps(reply_markup.to_dict()),
}
requests.post(url, data=dato)
def is_equal_inline_keyboards(keyboard_1: InlineKeyboardMarkup,
keyboard_2: InlineKeyboardMarkup) -> bool:
keyboard_1 = keyboard_1.to_dict()['inline_keyboard']
keyboard_2 = keyboard_2.to_dict()['inline_keyboard']
return keyboard_1 == keyboard_2
def test_create_reply_markup(self):
'''create_reply_markup returns same structures as if made manually'''
# Single type: callback_data
m1 = InlineKeyboardMarkup([[
InlineKeyboardButton('single_data_t1', callback_data='single_data_d1'),
InlineKeyboardButton('single_data_t2', callback_data='single_data_d2'),
]])
m2 = create_reply_markup([
('single_data_t1', 'single_data_d1'),
('single_data_t2', 'single_data_d2'),
])
self.assertDictEqual(
m1.to_dict(), m2.to_dict(),
'single type (callback_data) reply_markup not working'
)
# Single type: url
m1 = InlineKeyboardMarkup([[
InlineKeyboardButton('single_data_t1', url='single_data_u1'),
InlineKeyboardButton('single_data_t2', url='single_data_u2'),
]])
m2 = create_reply_markup([
('single_data_t1', None, 'single_data_u1'),
('single_data_t2', None, 'single_data_u2'),
])
self.assertDictEqual(
m1.to_dict(), m2.to_dict(),
'single type (url) reply_markup not working'
)
# Mixed type: callback_data and url
m1 = InlineKeyboardMarkup([[
InlineKeyboardButton('mixed_t1', callback_data='mixed_d1'),
InlineKeyboardButton('mixed_t2', url='mixed_u1'),
InlineKeyboardButton('mixed_t3', callback_data='mixed_d2'),
InlineKeyboardButton('mixed_t4', url='mixed_u2'),
]])
m2 = create_reply_markup([
('mixed_t1', 'mixed_d1'),
('mixed_t2', None, 'mixed_u1'),
('mixed_t3', 'mixed_d2'),
('mixed_t4', None, 'mixed_u2'),
])
self.assertDictEqual(
m1.to_dict(), m2.to_dict(),
'mixed types reply_markup not working'
)
# Multiple rows single type
m1 = InlineKeyboardMarkup([
[InlineKeyboardButton('multirow_single_t1', callback_data='multirow_single_d1')],
[InlineKeyboardButton('multirow_single_t2', callback_data='multirow_single_d2')],
])
m2 = create_reply_markup(
[('multirow_single_t1', 'multirow_single_d1')],
[('multirow_single_t2', 'multirow_single_d2')],
)
self.assertDictEqual(
m1.to_dict(), m2.to_dict(),
'multiple rows single type reply_markup not working'
)
# Multiple rows multiple type
m1 = InlineKeyboardMarkup([
[InlineKeyboardButton('multirow_mult_t1', callback_data='multirow_mult_d1')],
[InlineKeyboardButton('multirow_mult_t2', url='multirow_mult_u1')],
[InlineKeyboardButton('multirow_mult_t3', callback_data='multirow_mult_d2')],
[InlineKeyboardButton('multirow_mult_t4', url='multirow_mult_u2')],
])
m2 = create_reply_markup(
[('multirow_mult_t1', 'multirow_mult_d1')],
[('multirow_mult_t2', None, 'multirow_mult_u1')],
[('multirow_mult_t3', 'multirow_mult_d2')],
[('multirow_mult_t4', None, 'multirow_mult_u2')],
)
self.assertDictEqual(
m1.to_dict(), m2.to_dict(),
'multiple rows multiple type reply_markup not working'
)
