def test_one_page_keyboard_json_markup_with_before():
for test_case in one_page_test_cases:
paginator = InlineKeyboardPaginator(*test_case)
paginator.add_before(
*extra_buttons
)
keyboard = json.loads(paginator.markup)['inline_keyboard']
_verify_extra_buttons(keyboard[0])
def test_json_markup_with_before():
for args, labels in label_test_cases.items():
paginator = InlineKeyboardPaginator(*args)
paginator.add_before(
*extra_buttons
)
keyboard = json.loads(paginator.markup)['inline_keyboard']
_verify_extra_buttons(keyboard[0])
if not labels:
continue
assert len(keyboard[1]) == len(labels), \
'In case init args {} button count not correct. Mast be {}'.format(args, len(labels))
def paginator(self, page, bot, edit_mess_id, first_res):
paginator = InlineKeyboardPaginator(page_count=self.total_page,
current_page=page,
data_pattern='Trang#{page}')
if first_res:
print('===')
end = timeit.default_timer()
print('time send message :', end)
print('time inference :', str(end - self.start))
bot.sendMessage(
chat_id=self.chat_id,
# text=text,
text=self.render_mess(page),
reply_to_message_id=self.msg_id,
reply_markup=paginator.markup)
else:
print('===')
end = timeit.default_timer()
print('time send message :', end)
print('time inference :', str(end - self.start))
bot.editMessageText(chat_id=self.chat_id,
text=self.render_mess(page),
message_id=edit_mess_id,
reply_markup=paginator.markup)
def send_text(message, page=1, for_paging=False):
if not for_paging:
log_user_msgs(message.text, message.from_user)
user_message = message.text.lower()
chat_id = message.chat.id
else:
user_message, chat_id = message.split("~")
msgs = generate_answer("chat", user_message, page)
total = count_matched_documents(user_message)
# markup = generate_pages(total, page, user_message)
# bot.send_message(
# message.chat.id,
# msgs,
# reply_markup=markup
# )
if total > per_page:
paginator = InlineKeyboardPaginator(
math.ceil(total / per_page),
current_page=page,
data_pattern=user_message+'~'+str(chat_id)+'#{page}'
)
bot.send_message(
chat_id,
msgs,
reply_markup=paginator.markup if total > per_page else [],
parse_mode='Markdown'
)
def test_callback_data():
for page_count in range(2, 6):
for current_page in range(2, 6):
paginator = InlineKeyboardPaginator(page_count, current_page, data_pattern='test#{page}#')
keyboard = paginator.keyboard
for button, num in zip(keyboard, range(1, 6)):
data = 'test#{}#'.format(num)
assert button['callback_data'] == data, \
'In case init args {} callback_data mast be {}'.format((page_count, current_page, 'test#{page}#'), data)
for args, output in data_test_case.items():
paginator = InlineKeyboardPaginator(*args)
keyboard = paginator.keyboard
for button, data in zip(keyboard, output):
assert button['callback_data'] == data, \
'In case init args {} callback_data mast be {}'.format(args, data)
async def test(message: types.Message, state: FSMContext):
paginator = InlineKeyboardPaginator(len(data),
current_page=0,
data_pattern='page#{page}')
# await TestState.TestState.set()
await state.update_data(test_state="Test_State")
await message.answer(data[0], reply_markup=paginator.markup)
def start(update, context):
paginator = InlineKeyboardPaginator(len(character_pages),
data_pattern='character#{page}')
update.message.reply_text(text=character_pages[0],
reply_markup=paginator.markup,
parse_mode='Markdown')
async def send_character_page(message, page=1):
paginator = InlineKeyboardPaginator(len(get_quontation()),
current_page=page,
data_pattern='character#{page}')
await bot.send_message(message.chat.id,
get_quontation()[page - 1],
reply_markup=paginator.markup,
parse_mode='Markdown')
def test_button_label():
for args, labels in label_test_cases.items():
paginator = InlineKeyboardPaginator(*args)
keyboard = paginator.keyboard
assert len(keyboard) == len(labels), \
'In case init args {} button count not correct. Mast be {}'.format(args, len(labels))
for button, label in zip(keyboard, labels):
assert button['text'] == label, \
'In case init args {} button label not correct. Must be {}'.format(args, label)
def test_json_markup_with_after():
for args, labels in label_test_cases.items():
paginator = InlineKeyboardPaginator(*args)
paginator.add_after(
*extra_buttons
)
keyboard = json.loads(paginator.markup)['inline_keyboard']
if not labels:
_verify_extra_buttons(keyboard[0])
continue
assert len(keyboard[0]) == len(labels), \
'In case init args {} button count not correct. Mast be {}'.format(args, len(labels))
# for button, label in zip(keyboard[0], labels):
# assert button['text'] == label, \
# 'In case init args {} button label not correct. Must be {}'.format(args, label)
_verify_extra_buttons(keyboard[1])
async def send_current_page(message: types.Message, page: int = 1):
""" Отображает текущую страницу из списка temp_text """
try:
paginator = InlineKeyboardPaginator(len(temp_text),
current_page=page,
data_pattern='character#{page}')
answer_message = temp_text[page - 1]
await message.answer(answer_message, reply_markup=paginator.markup)
except Exception as ex:
await message.answer("!!! Something bad with paging !!!\n"
f"{ex, ex.args}")
def on_request(update: Update, context: CallbackContext):
message = update.message
paginator = InlineKeyboardPaginator(page_count=len(character_pages),
current_page=1,
data_pattern='character#{page}')
character = character_pages[0]
message.reply_photo(photo=open(character['image'], 'rb'),
caption="*{title}*".format(**character),
reply_markup=paginator.markup,
parse_mode=ParseMode.MARKDOWN)
def send_character_page(message, page=1):
paginator = InlineKeyboardPaginator(
len(character_pages),
current_page=page,
data_pattern='character#{page}'
)
bot.send_message(
message.chat.id,
character_pages[page-1],
reply_markup=paginator.markup,
parse_mode='Markdown'
)
async def send_opening(message, page=1):
paginator = InlineKeyboardPaginator(
len(openings),
current_page=page,
data_pattern='openings#{page}'
)
text = f"текст вакансии: {openings[page - 1].description}, \nПрислала: {openings[page - 1].contact}"
await bot.send_message(
chat_id=message.chat.id,
text=text,
reply_markup=paginator.markup,
parse_mode='Markdown'
)
def send_character_page(message, page=1):
# print(pers)
chat_id = message.chat.id
global clients
if not clients[chat_id]:
bot.send_message(chat_id,
'База пуста, отправьте файл. Информация /start')
return
paginator = InlineKeyboardPaginator(len(clients[chat_id]) // 6 + 1,
current_page=page,
data_pattern='character#{page}')
for i in clients[chat_id][6 * (page - 1):6 * page]:
paginator.add_before(
InlineKeyboardButton(str(i[0]) + ':' + i[1],
callback_data='pers:{}'.format(i[0])))
print(page)
bot.send_message(message.chat.id,
msg(clients[chat_id][page - 1]),
reply_markup=paginator.markup,
parse_mode='Markdown')
def characters_page_callback(update, context):
query = update.callback_query
query.answer()
page = int(query.data.split('#')[1])
paginator = InlineKeyboardPaginator(len(character_pages),
current_page=page,
data_pattern='character#{page}')
query.edit_message_text(text=character_pages[page - 1],
reply_markup=paginator.markup,
parse_mode='Markdown')
async def callback_test(call: CallbackQuery, state: FSMContext):
print(f'-> {call.data}')
page = call.data.split('#')[1]
print(f'page={str(page)}')
# await call.message.answer(call.message.text)
paginator = InlineKeyboardPaginator(len(data),
current_page=int(page),
data_pattern='page#{page}')
await call.message.edit_text(data[int(page) - 1],
reply_markup=paginator.markup)
data_state = await state.get_data()
test_data = data_state.get("test_state")
print(f"test_data = {test_data}")
async def show_openings(call, openings):
paginator = InlineKeyboardPaginator(
len(openings),
data_pattern='openings#{page}'
)
text = f"Последняя присланная вакансия: \n" \
f"текст вакансии: {openings[-1].description}" \
f"\nПрислала: {openings[-1].contact}"
await call.reply(
text=text,
reply_markup=paginator.markup,
parse_mode='Markdown'
)
def send_character_page(message, page=1):
url = last_queries[str(message.chat.id)]
result, meta = csapi.query_clearspending_text(url, page)
if meta == None or meta["pages"] == 1:
set_last_query(message, None)
bot.send_message(message.chat.id, result, parse_mode="HTML")
return
pieces = util.split_string(result, 3000)
if len(pieces) > 1:
for piece in pieces[:len(pieces) - 2]:
msg = bot.send_message(message.chat.id, piece, parse_mode="HTML")
add_to_delete_buffer(msg)
paginator = InlineKeyboardPaginator(meta["pages"],
current_page=page,
data_pattern='character#{page}')
paginator.add_after(InlineKeyboardButton('Отмена', callback_data='back'))
bot.send_message(message.chat.id,
pieces[-1],
reply_markup=paginator.markup,
parse_mode='HTML')
def send_character_page(update, pages, page=1):
"""
Create pages
:param telegram.Update update: Bot updater object
:param list pages: List with message to print on each page
:param int page: Current number of page
"""
paginator = InlineKeyboardPaginator(len(pages),
current_page=page,
data_pattern='character#{page}')
update.message.reply_text(pages[page - 1],
reply_markup=paginator.markup,
parse_mode='Markdown')
def on_request(update: Update, context: CallbackContext):
message = update.message
paginator = InlineKeyboardPaginator(
page_count=len(character_pages),
current_page=1,
data_pattern='character#{page}'
)
character = character_pages[0]
message.reply_text(
text='*{title}*\n{description}'.format(**character),
reply_markup=paginator.markup,
parse_mode=ParseMode.MARKDOWN
)
def send_news(message, keyword, page=1, by_source=True):
paginator = InlineKeyboardPaginator(
10,
current_page=page,
data_pattern='Новости#'+keyword+'#{page}'
)
if by_source is not True:
a = get_news_from_db_by_source(keyword, page)
else:
a = get_news_from_db(keyword, page)
bot.send_message(
message.chat.id,
a,
reply_markup=paginator.markup,
parse_mode='html',
disable_web_page_preview=True
)
def vacancy_paginator(vacancies: list, pattern: str, page: int, text: str,
update, context):
vacancies = vacancies[::-1]
if len(vacancies) == 0:
inline_keyboard = [[
InlineKeyboardButton('Вернуться ', callback_data='start')
]]
inline_buttons = InlineKeyboardMarkup(inline_keyboard=inline_keyboard)
update.callback_query.edit_message_text(
text='Не найдено. Попробуйте изменить фильтр',
reply_markup=inline_buttons)
else:
page_num = page_definer(vacancies)
paginator = InlineKeyboardPaginator(page_num,
current_page=page,
data_pattern=f'{pattern}' +
'#{page}')
# Defining a range of vacancies that should be applicable to current page
# And adding each vacancy as a new button
vacancies_range = vacancies[page * PAGE_SPLIT - PAGE_SPLIT:page *
PAGE_SPLIT]
for i in vacancies_range:
paginator.add_before(
InlineKeyboardButton(
text=f'{i["title"]} | {i["salary"]} | {i["joining_date"]}',
callback_data=f'detail_{pattern}' + f'#{page}' +
f'_{i["id"]}'))
# If user pressed current page twicely, than will add space to button
# To change markup and avoid BadRequest error from telegram
if context.user_data[CURRENT_PAGE] == page:
paginator.add_after(
InlineKeyboardButton('Вернуться ', callback_data='start'))
else:
paginator.add_after(
InlineKeyboardButton('Вернуться', callback_data='start'))
update.callback_query.edit_message_text(text=text,
reply_markup=paginator.markup,
parse_mode='Markdown')
# Updating current page to real current page
context.user_data[CURRENT_PAGE] = page
return ConversationHandler.END
def send_character_page(message, page=1):
paginator = InlineKeyboardPaginator(len(character_pages),
current_page=page,
data_pattern='character#{page}')
paginator.add_before(
InlineKeyboardButton('Like', callback_data='like#{}'.format(page)),
InlineKeyboardButton('Dislike',
callback_data='dislike#{}'.format(page)))
paginator.add_after(InlineKeyboardButton('Go back', callback_data='back'))
bot.send_message(message.chat.id,
character_pages[page - 1],
reply_markup=paginator.markup,
parse_mode='Markdown')
def show_subs(bot, update):
table_id = update.user_data[
'id'] = bot.message.text # временно сохраняем ответ
if table_id not in ['1', '2', '3']:
update.bot.send_message(bot.message.chat.id,
text='Некорректный номер',
parse_mode=ParseMode.HTML)
return ConversationHandler.END
free_sub_count = 0
conn = create_connection()
sub_list = select_subs(conn, table_id)
decoded_table_name = decode_table_name(table_id)
if not sub_list:
update.bot.send_message(
bot.message.chat.id,
text=f"А нет аккаунтов <b>{decoded_table_name}</b>",
parse_mode=ParseMode.HTML)
return ConversationHandler.END
update.bot.send_message(bot.message.chat.id,
text=f'<b>Подписки {decoded_table_name}</b>\n\n',
parse_mode=ParseMode.HTML)
for sub in sub_list:
if sub[4] == 0:
free_sub_count += 1
formed_list = form_sub_text(sub_list, 5)
sub = formed_list[0]
paginator = InlineKeyboardPaginator(len(formed_list),
data_pattern='character#{page}#' +
str(table_id))
update.bot.send_message(chat_id=bot.message.chat.id,
text=sub,
reply_markup=paginator.markup,
parse_mode=ParseMode.HTML)
update.bot.send_message(
bot.message.chat.id,
text=
f'<b>Всего</b>: {len(sub_list)}\n<b>Непроданных</b>: {free_sub_count}',
parse_mode=ParseMode.HTML)
return ConversationHandler.END
def on_callback_query(update: Update, context: CallbackContext):
query = update.callback_query
query.answer()
source, page = query.data.split('#', 1)
page = int(page)
paginator = InlineKeyboardPaginator(page_count=len(character_pages),
current_page=page,
data_pattern=source + '#{page}')
# Fix error: "telegram.error.BadRequest: Message is not modified"
if is_equal_inline_keyboards(paginator, query.message.reply_markup):
return
character = character_pages[page - 1]
query.message.edit_media(media=InputMediaPhoto(
media=open(character['image'], 'rb'),
caption="*{title}*".format(**character),
parse_mode=ParseMode.MARKDOWN),
reply_markup=paginator.markup)
async def callback_paginator_for_paying(call: CallbackQuery,
state: FSMContext):
# print(f'callback_paginator for paying -> {str(call.from_user.id)}')
await state.reset_state(with_data=False)
call_data = call.data
state_name = ""
# print(f"call_data = {call_data}")
if call_data == 'signed':
page = 1
state_name = get_state_name(str(call_data))
enquiries = Enquiry(call.from_user.id)
# fetching data from DB
entities = enquiries.get_entities_for_paying(state_name, "Нет")
await state.update_data(request_data=entities,
state_name=state_name,
call_data=call_data)
data_state = await state.get_data()
request_data = data_state.get("request_data")
# print(f"request_data = {request_data}")
else:
data_state = await state.get_data()
request_data = data_state.get("request_data")
# print(f"request_data = {request_data}")
page = int(call.data.split('&')[1])
# print(f'page={str(page)}')
paginator = InlineKeyboardPaginator(
0 if request_data is None else len(request_data),
current_page=int(page),
data_pattern='page&{page}')
if len(request_data) if request_data is not None else 0 > 0:
if data_state.get("call_data") == 'signed':
paginator.add_after(
InlineKeyboardButton(
text="{} Запросить выплату для всех выполненных заявок".
format(emojize(":bell:")),
callback_data="task_sign&{}".format(request_data[
page - 1]["id"] if len(request_data) > 0 else [])))
paginator.add_after(
InlineKeyboardButton("{} Назад".format(
emojize(":leftwards_arrow_with_hook:")),
callback_data="choice_buttons"))
await call.message.edit_text(format_enquiry_for_paying(
request_data[page - 1] if len(request_data) > 0 else []),
reply_markup=paginator.markup)
def characters_page_callback(update, context):
query = update.callback_query
query.answer()
page = int(query.data.split('#')[1])
paginator = InlineKeyboardPaginator(len(character_pages),
current_page=page,
data_pattern='character#{page}')
paginator.add_before(
InlineKeyboardButton('Like', callback_data='like#{}'.format(page)),
InlineKeyboardButton('Dislike',
callback_data='dislike#{}'.format(page)))
paginator.add_after(InlineKeyboardButton('Go back', callback_data='back'))
query.edit_message_text(text=character_pages[page - 1],
reply_markup=paginator.markup,
parse_mode='Markdown')
def reply_text_or_edit_with_keyboard_paginator(
message: Message,
query: Optional[CallbackQuery],
text: str,
page_count: int,
items_per_page: int,
current_page: int,
data_pattern: str,
before_inline_buttons: List[InlineKeyboardButton] = None,
after_inline_buttons: List[InlineKeyboardButton] = None,
quote: bool = False,
**kwargs,
):
page_count = math.ceil(page_count / items_per_page)
paginator = InlineKeyboardPaginator(
page_count=page_count,
current_page=current_page,
data_pattern=data_pattern,
)
if before_inline_buttons:
paginator.add_before(*before_inline_buttons)
if after_inline_buttons:
paginator.add_after(*after_inline_buttons)
reply_markup = paginator.markup
reply_text_or_edit_with_keyboard(
message,
query,
text,
reply_markup,
quote=quote,
**kwargs,
)
def test_json_markup():
for args, markup in markup_test_cases.items():
paginator = InlineKeyboardPaginator(*args)
assert paginator.markup == markup, \
'In case init args {} markup not correct'.format(args)
