async def add_key_for_text(message: types.Message):
if await key_split(message.text):
await CreateBlurb.text.set()
key_under_blurb = InlineKeyboardMarkup(row_width=1)
k = InlineKeyboardButton(text=config.url_text_blurb,
url=config.url_link_blurb)
j = InlineKeyboardButton(text='Удалить кнопку',
callback_data='del_key_blurb')
m = InlineKeyboardButton(text='Сохранить', callback_data='save_blurb')
n = InlineKeyboardButton(text='Назад', callback_data='add_blurb')
key_under_blurb.insert(k)
key_under_blurb.insert(j)
key_under_blurb.insert(m)
key_under_blurb.insert(n)
text = '{}'.format(config.text_blurb)
if config.preview_blurb == 1:
await message.answer(text=text,
parse_mode=config.parse_blurb,
disable_web_page_preview=True,
reply_markup=key_under_blurb)
else:
await message.answer(text=text,
parse_mode=config.parse_blurb,
disable_web_page_preview=False,
reply_markup=key_under_blurb)
else:
await message.answer(
'Не правильно переданы параметры, повторите попытку',
reply_markup=key_addKey_back)
async def items_keyboard(category):
CURRENT_LEVEL = 1
markup = InlineKeyboardMarkup(row_width=1)
items = await get_items(category)
for item in items:
button_text = f"{item.name}"
callback_data = make_callback_data(
level=CURRENT_LEVEL + 1,
category=category,
item_id=item.id,
)
markup.insert(
InlineKeyboardButton(text=button_text,
callback_data=callback_data))
markup.row(
InlineKeyboardButton(text="← Назад",
callback_data=make_callback_data(
level=CURRENT_LEVEL - 1,
category=category,
)))
return markup
async def _get_days_kb(self, year: int, month: int):
inline_kb = InlineKeyboardMarkup(row_width=7)
inline_kb.row()
inline_kb.insert(
InlineKeyboardButton(year,
callback_data=calendar_callback.new(
"START", year, -1, -1)))
inline_kb.insert(
InlineKeyboardButton(self.months[month - 1],
callback_data=calendar_callback.new(
"SET-YEAR", year, -1, -1)))
inline_kb.row()
for day in ["Mo", "Tu", "We", "Th", "Fr", "Sa", "Su"]:
inline_kb.insert(
InlineKeyboardButton(day, callback_data=ignore_callback))
month_calendar = calendar.monthcalendar(year, month)
for week in month_calendar:
inline_kb.row()
for day in week:
if (day == 0):
inline_kb.insert(
InlineKeyboardButton(" ",
callback_data=ignore_callback))
continue
inline_kb.insert(
InlineKeyboardButton(str(day),
callback_data=calendar_callback.new(
"SET-DAY", year, month, day)))
return inline_kb
def data_keyboard(
data: Union[List[Project], List[Campus]],
action: str,
content: Union[str, int],
limit: int,
current_id: int = 0,
page: int = 0,
back_button_data: Tuple[str, str] = None) -> InlineKeyboardMarkup:
keyboard = InlineKeyboardMarkup(row_width=3)
count = len(data[page * limit:])
data = paginate(data=data, page=page, limit=limit)
for entity in data:
text = entity.name if current_id != entity.id else f'✅ {entity.name}'
callback_data = f'{action}.{content}.{entity.id}.{page}'
keyboard.insert(InlineKeyboardButton(text,
callback_data=callback_data))
keyboard = pagination_keyboard(action=f'{action}_pagination',
count=count,
content=content,
limit=limit,
stop=9,
page=page,
keyboard=keyboard,
back_button_data=back_button_data)
return keyboard
async def items_keyboard(category: str, level: int = 2):
CURRENT_LEVEL = level
# Set row_width = 1 to show one button per row per item
markup = InlineKeyboardMarkup(row_width=1)
# Take a list of goods from the database
items = await get_items(category)
for item in items:
# Form the button text
button_text = f"{item.name} {item.emodji}"
# Form a button callback data
callback_data = make_callback_data(level=CURRENT_LEVEL + 1,
category=category,
item_id=item.id)
markup.insert(
InlineKeyboardButton(text=button_text,
callback_data=callback_data))
# Create a Back button
markup.row(
InlineKeyboardButton(text='Назад 🔙',
callback_data=make_callback_data(
level=CURRENT_LEVEL - 1, category=category)))
return markup
def get_collapse_markup(id: int) -> InlineKeyboardMarkup:
button = InlineKeyboardButton(text='collapse',
callback_data=f'collapse {id}')
markup = InlineKeyboardMarkup()
markup.insert(button)
return markup
async def admin_kb():
admin_main_kb = InlineKeyboardMarkup(row_width=2)
button_rows = [[
InlineKeyboardButton(_('Quests'), callback_data='admin_quests'),
InlineKeyboardButton(_('News'), callback_data='admin_news')
],
[
InlineKeyboardButton(_('App'),
callback_data='admin_app'),
InlineKeyboardButton(_('Stats'),
callback_data='admin_stats')
],
[
InlineKeyboardButton(_('Announcement'),
callback_data='make_anno')
],
InlineKeyboardButton(_('Exit admin panel'),
callback_data='back_to_main_menu')]
for x in button_rows:
if type(x) is list:
admin_main_kb.add(x[0])
for b in x[1:]:
admin_main_kb.insert(b)
else:
admin_main_kb.add(x)
return admin_main_kb
async def items_keyboard(category, subcategory):
CURRENT_LEVEL = 2
# Устанавливаю row_width = 1, чтобы показывалась одна кнопка в строке на товар
markup = InlineKeyboardMarkup(row_width=1)
# Забираем список товаров из базы данных с выбранной категорией и подкатегорией, и проходим по нему
items = await get_items(category, subcategory)
for item in items:
# Сформируем текст, который будет на кнопке
button_text = f"{item.name} - ${item.price}"
# Сформируем колбек дату, которая будет на кнопке
callback_data = make_callback_data(level=CURRENT_LEVEL + 1,
category=category,
subcategory=subcategory,
item_id=item.id)
markup.insert(
InlineKeyboardButton(text=button_text,
callback_data=callback_data))
# Создаем Кнопку "Назад", в которой прописываем колбек дату такую, которая возвращает
# пользователя на уровень назад - на уровень 1 - на выбор подкатегории
markup.row(
InlineKeyboardButton(text="Назад",
callback_data=make_callback_data(
level=CURRENT_LEVEL - 1, category=category)))
return markup
async def keyboard_payment_menu(goods_pk: int, city: str, address: str,
quantity: int) -> InlineKeyboardMarkup:
CURRENT_LEVEL = 4
markup = InlineKeyboardMarkup(row_width=1)
payments = await select_all_payments()
for payment in payments:
callback_data = make_purchase_cd(level=CURRENT_LEVEL + 1,
goods_pk=goods_pk,
city=city,
address=address,
quantity=str(quantity),
payment=payment.payment)
button = InlineKeyboardButton(f"{payment.payment}",
callback_data=callback_data)
markup.insert(button)
callback_data = make_purchase_cd(level=CURRENT_LEVEL - 1,
goods_pk=goods_pk,
city=city,
address=address,
quantity=str(quantity))
await add_misc_buttons(markup, callback_data)
return markup
async def manime(message):
query = get_args_str(message).lower()
headers = {
"User-Agent":
"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:70.0) Gecko/20100101 Firefox/70.0"
}
query.replace('', '%20')
surl = f'https://api.jikan.moe/v3/search/anime?q={urlencode(query)}'
session = aiohttp.ClientSession()
async with session.get(surl) as resp:
a = await resp.json()
if 'results' in a.keys():
pic = f'{a["results"][0]["image_url"]}'
info = f'{a["results"][0]["title"]}\n'
info += f' • Airing : {a["results"][0]["airing"]}\n'
info += f' • Type : {a["results"][0]["type"]}\n'
info += f' • Episodes : {a["results"][0]["episodes"]}\n'
info += f' • Score : {a["results"][0]["score"]}\n'
info += f' • Rated : {a["results"][0]["rated"]}\n'
info += f' • Synopsis : {a["results"][0]["synopsis"]}\n'
mlink = f'{a["results"][0]["url"]}\n'
link_btn = InlineKeyboardMarkup()
link_btn.insert(InlineKeyboardButton("MyAnimeList Link",
url=mlink))
await message.reply_photo(pic, caption=info, reply_markup=link_btn)
async def subcategories_keyboard(category):
# Текущий уровень - 1
CURRENT_LEVEL = 1
markup = InlineKeyboardMarkup()
# Забираем список товаров с РАЗНЫМИ подкатегориями из базы данных с учетом выбранной категории и проходим по ним
subcategories = await get_subcategories(category)
for subcategory in subcategories:
# Чекаем в базе сколько товаров существует под данной подкатегорией
number_of_items = await count_items(
category_code=category,
subcategory_code=subcategory.subcategory_code)
# Сформируем текст, который будет на кнопке
button_text = f"{subcategory.subcategory_name} ({number_of_items} шт)"
# Сформируем колбек дату, которая будет на кнопке
callback_data = make_callback_data(
level=CURRENT_LEVEL + 1,
category=category,
subcategory=subcategory.subcategory_code)
markup.insert(
InlineKeyboardButton(text=button_text,
callback_data=callback_data))
# Создаем Кнопку "Назад", в которой прописываем колбек дату такую, которая возвращает
# пользователя на уровень назад - на уровень 0.
markup.row(
InlineKeyboardButton(
text="Назад",
callback_data=make_callback_data(level=CURRENT_LEVEL - 1)))
return markup
async def back_access(data: str) -> str:
inline_kb_to_choose = InlineKeyboardMarkup(row_width=6)
temp = 1
result_string = ''
if data['type'] == "all":
data = get_all_reminders()
type_string = "reminders"
elif data['type'] == "perm":
data = get_permanent_reminders()
type_string = "permanent reminders"
elif data['type'] == "temp":
data = get_temporary_reminders()
type_string = "temporary reminders"
elif data['type'] == "book":
data = get_bookmarks()
type_string = "bookmarks"
else:
raise KeyError
if data:
for elem in data:
inline_btn = InlineKeyboardButton(temp,
callback_data=f"edit_{elem[0]}")
inline_kb_to_choose.insert(inline_btn)
result_string += answer_forms(element=elem,
position=temp,
adding=True)
temp += 1
else:
result_string, inline_kb_to_choose = f"No {type_string} in system.", remindersMenu
return result_string, inline_kb_to_choose
async def deal_type_keyboard():
# Указываем, что текущий уровень меню - 0
CURRENT_LEVEL = 0
# Создаем Клавиатуру
markup = InlineKeyboardMarkup()
# Забираем список типов сделок из базы данных
types = await get_deal_type()
# Проходимся циклом по доступным нам типам сделок
for type in types:
# Чекаем в базе сколько недвижимости существует под данным типом сделки
number_of_estates = await count_estates(type.deal_type)
# Сформируем текст, который будет на кнопке
button_text = f"{type.deal_type} ({number_of_estates} шт)"
# Сформируем колбек дату, которая будет на кнопке. Следующий уровень - текущий + 1, и перечисляем типы сделок
callback_data = make_callback_data(level=CURRENT_LEVEL + 1,
deal_type=type.deal_type)
# Вставляем кнопку в клавиатуру
markup.insert(
InlineKeyboardButton(text=button_text,
callback_data=callback_data))
# Возвращаем созданную клавиатуру в хендлер
return markup
async def show_menu(message: Message):
#По ссылке парсим все
URL_YANDEX_NEWS = 'https://yandex.ru/news/export'
r = requests.get(URL_YANDEX_NEWS)
soup = BeautifulSoup(r.text, 'html.parser')
#словарь будет хранить все URL(value) + text(key)
allHref = {}
#выбираем только ссылки
for link in soup.find_all("a"):
allHref[link.string] = link.get("href")
#Из всех выбираем только те что для избранной рубрики
#категории указаны в файле RubricText.txt
favoriteСategories = []
with open('RubricText.txt', 'r', encoding="utf-8") as f:
favoriteСategories = f.read().splitlines()
#словарь будет хранить только необходимые рубрики URL + text
needLink = {}
#перебираем все элементы списка и проверяем если такой ключ в словаре
for item in favoriteСategories:
if item in allHref:
needLink[item] = allHref[item]
#формируем кнопки
buttonRubric = InlineKeyboardMarkup(row_width=2)
for item in needLink:
buttonRubric.insert(InlineKeyboardButton(text=item, callback_data=needLink[item]))
await message.answer(text="Укажите рубрику", reply_markup=buttonRubric)
def albums_keyboard(artist, albums):
kb = InlineKeyboardMarkup(1)
for album in albums:
year = album.release_date.split('-')[0]
kb.insert(InlineKeyboardButton(f'{album.title} ({year})', callback_data=new_callback('album', album.id, 'send')))
kb.insert(InlineKeyboardButton('Go back', callback_data=new_callback('artist', artist.id, 'main')))
return kb
async def add_misc_buttons(markup: InlineKeyboardMarkup,
callback_data: str) -> None:
button_back = InlineKeyboardButton(text="Назад",
callback_data=callback_data)
button_cancel = InlineKeyboardButton(text="Отмена", callback_data="cancel")
markup.insert(button_back)
markup.insert(button_cancel)
def create_admin_keyboard():
admin_keyboard = InlineKeyboardMarkup(row_width=1)
admin_keyboard.insert(
InlineKeyboardButton(text="Обновить популярность",
callback_data=admin_callback.new(
tool_name="update_players",
league_name="None")))
admin_keyboard.insert(
InlineKeyboardButton(
text="Обновить коэффициенты",
callback_data=admin_callback.new(tool_name="update_coeffs",
league_name="None")))
admin_keyboard.insert(
InlineKeyboardButton(
text="Обновить статистику",
callback_data=admin_callback.new(tool_name="update_stats",
league_name="None")))
admin_keyboard.insert(
InlineKeyboardButton(text="Обновить все!",
callback_data=admin_callback.new(
tool_name="update_all", league_name="None")))
admin_keyboard.insert(
InlineKeyboardButton(text="Назад",
callback_data=admin_callback.new(
tool_name="cancel", league_name="None")))
return admin_keyboard
async def send_profile(db_user: User, message: types.Message):
to_send = res_dict['profile_moderator'].format(db_user.real_fullname,
db_user.phone_n)
keyboard = InlineKeyboardMarkup()
keyboard.insert(
InlineKeyboardButton('Редактировать', callback_data='edit_profile'))
await message.answer(to_send, parse_mode='html', reply_markup=keyboard)
async def anime(message):
query = get_args_str(message).lower()
headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:70.0) Gecko/20100101 Firefox/70.0"}
query.replace('', '%20')
url = f'https://kitsu.io/api/edge/anime?filter%5Btext%5D={urlencode(query)}'
session = aiohttp.ClientSession()
async with session.get(url) as resp:
a = await resp.json()
if 'data' in a.keys():
data = a["data"][0]
pic = f'{data["attributes"]["coverImage"]["original"] if data["attributes"].get("coverImage", "") else ""}'
id = f'{a["data"][0]["id"]}'
info = f'{data["attributes"]["titles"]["en_jp"]}\n'
info += f'{data["attributes"]["titles"]["ja_jp"]}\n'
info += f' * Rating: {data["attributes"]["averageRating"]}\n'
info += f' * Release Date: {data["attributes"]["startDate"]}\n'
info += f' * End Date: {data["attributes"]["endDate"]}\n'
info += f' * Status: {data["attributes"]["status"]}\n'
info += f' * Description: {data["attributes"]["description"]}\n'
aurl = f'kitsu.io/anime/'+id
if len(info) > 1024:
info = info[0:500] + "...."
link_btn = InlineKeyboardMarkup()
link_btn.insert(InlineKeyboardButton("Read more", url=aurl))
if pic:
await message.reply_photo(pic, caption=info, reply_markup=link_btn)
else:
await message.reply_text(info, reply_markup=link_btn)
def create_options_kb(options: list):
kb_options = InlineKeyboardMarkup(row_width=2)
for button in options:
kb_options.insert(
InlineKeyboardButton(text=button, callback_data=button))
return kb_options
def alone_peer_keyboard(
user: User, login: str,
keyboard: InlineKeyboardMarkup) -> InlineKeyboardMarkup:
for k, v in Config.local.alone_peer_menu.get(user.language).items():
keyboard.insert(
InlineKeyboardButton(text=v, callback_data=f'{k}.{login}'))
return keyboard
async def preview_keyboard(section_name, dater):
CURRENT_LEVEL = 2
markup = InlineKeyboardMarkup(row_width=1)
markup.insert(
InlineKeyboardButton(text="Заголовок и превью",
callback_data=make_callback_data(
level=CURRENT_LEVEL + 1,
section_name=section_name,
dater=dater,
preview=False)))
markup.insert(
InlineKeyboardButton(text="Только заголовок",
callback_data=make_callback_data(
level=CURRENT_LEVEL + 1,
section_name=section_name,
dater=dater,
preview=True)))
markup.row(
InlineKeyboardButton(text="Назад",
callback_data=make_callback_data(
level=CURRENT_LEVEL - 1,
section_name=section_name)))
markup.row(InlineKeyboardButton(text="Отмена", callback_data="cancel"))
return markup
async def categories_keyboard(level: int = 1):
# Указываем, что текущий уровень меню - 0
CURRENT_LEVEL = 1
# Создаем Клавиатуру
markup = InlineKeyboardMarkup(row_width=1)
# Забираем список товаров из базы данных с РАЗНЫМИ категориями и проходим по нему
categories = await get_categories()
for category in categories:
# Чекаем в базе сколько товаров существует под данной категорией
number_of_items = await count_items(category.category_code)
# Сформируем текст, который будет на кнопке
button_text = f"{category.category_name} ({number_of_items} шт)"
# Сформируем колбек дату, которая будет на кнопке. Следующий уровень - текущий + 1, и перечисляем категории
callback_data = make_callback_data(level=CURRENT_LEVEL + 1,
category=category.category_code)
# Вставляем кнопку в клавиатуру
markup.insert(
InlineKeyboardButton(text=button_text,
callback_data=callback_data))
return markup
async def testing_answer(message: types.Message, state: FSMContext):
await state.update_data(answer=message.text)
data = await state.get_data()
current_difficult = data.get('current_difficult')
if current_difficult == 'easy':
btnAgain = InlineKeyboardButton("Ещё слово", callback_data='easy')
else:
btnAgain = InlineKeyboardButton("Ещё слово", callback_data='hard')
btnBack = InlineKeyboardButton("Вернуться назад", callback_data='back')
kbAgainOrBack = InlineKeyboardMarkup(row_width=1)
kbAgainOrBack.insert(btnAgain)
kbAgainOrBack.insert(btnBack)
if data.get('answer') == data.get('word_translate'):
await message.answer(
f"Верно! Это слово переводится, как {data.get('answer')}!",
reply_markup=kbAgainOrBack)
else:
await message.answer(
f"К сожалению, ты ошибься. Это слово переводится, как {data.get('word_translate')}. Будь "
f"внимательнее в следующий раз!",
reply_markup=kbAgainOrBack)
await Testing.difficult_selected.set()
async def back_query_handler(call: types.CallbackQuery):
user_id = call.from_user.id
txt = "Созданных игр пока нет. Можете создать свою по кнопкам ниже."
games_keyboard = InlineKeyboardMarkup(row_width=2)
games = db.get_new_games()
if games:
for g in games:
if g['telegram_id_host'] != user_id:
games_keyboard.insert(
InlineKeyboardButton(
f"игра #{g['id']} на {g['bet_amount']} рублей",
callback_data=games_play_callback.new(
type="game_preview", number=g['id'])))
txt = "Доступные игры:"
games_keyboard.add(
InlineKeyboardButton(
"Обновить", callback_data=games_callback.new(type="refresh")))
k1 = InlineKeyboardButton(
'Создать игру[Рубли]',
callback_data=games_callback.new(type="create_rubles"))
k2 = InlineKeyboardButton(
'Создать игру[Баллы]',
callback_data=games_callback.new(type="create_points"))
games_keyboard.add(k1, k2)
await call.message.delete()
await call.message.answer(txt, reply_markup=games_keyboard)
def playlist_keyboard(playlist, show_artists=False, post=False):
kb = InlineKeyboardMarkup(1)
for i, track in enumerate(playlist.tracks[:97], start=1):
if show_artists:
kb.insert(
InlineKeyboardButton(f'{i}.{track.artist} - {track.title}',
callback_data=new_callback(
'vk_track', track.full_id, 'send')))
else:
kb.insert(
InlineKeyboardButton(f'{i}. {track.title}',
callback_data=new_callback(
'vk_track', track.full_id, 'send')))
kb.insert(
InlineKeyboardButton('Get all tracks',
callback_data=new_callback(
'vk_playlist', playlist.full_id, 'download')))
if post:
kb.insert(
InlineKeyboardButton('Post',
callback_data=new_callback(
'vk_playlist', playlist.full_id, 'post')))
kb.insert(InlineKeyboardButton(text='Close', callback_data='close'))
return kb
async def _get_month_kb(self, year: int):
inline_kb = InlineKeyboardMarkup(row_width=6)
# first row with year button
inline_kb.row()
inline_kb.insert(
InlineKeyboardButton(" ", callback_data=ignore_callback))
inline_kb.insert(
InlineKeyboardButton(year,
callback_data=calendar_callback.new(
"START", year, -1, -1)))
inline_kb.insert(
InlineKeyboardButton(" ", callback_data=ignore_callback))
# two rows with 6 months buttons
inline_kb.row()
for month in self.months[0:6]:
inline_kb.insert(
InlineKeyboardButton(month,
callback_data=calendar_callback.new(
"SET-MONTH", year,
self.months.index(month) + 1, -1)))
inline_kb.row()
for month in self.months[6:12]:
inline_kb.insert(
InlineKeyboardButton(month,
callback_data=calendar_callback.new(
"SET-MONTH", year,
self.months.index(month) + 1, -1)))
return inline_kb
def profile_keyboard(tracks, profile_id, page, per_page=7):
kb = InlineKeyboardMarkup(2)
total_pages = ceil(len(tracks) / per_page)
start = (page - 1) * per_page
stop = start + per_page
last_page = page == total_pages
for i, track in enumerate(tracks[start:stop], start=start):
kb.row(
InlineKeyboardButton(f'{i+1}. {track.artist} - {track.title}',
callback_data=new_callback(
'vk_track', track.full_id, 'send')))
kb.row()
if page != 1:
kb.insert(
InlineKeyboardButton('◀️',
callback_data=new_callback(
'vk_profile_audio_page', profile_id,
page - 1)))
if not last_page:
kb.insert(
InlineKeyboardButton('️️▶️',
callback_data=new_callback(
'vk_profile_audio_page', profile_id,
page + 1)))
return kb
async def collect_menu_keyboard(page_number):
prod_on_page = 8
first_product_num = page_number * prod_on_page
last_product_num = first_product_num + prod_on_page
products = moltin_aps.get_all_products()
keyboard = InlineKeyboardMarkup(row_width=2)
for product in products[first_product_num:last_product_num]:
keyboard.insert(
InlineKeyboardButton(product['name'], callback_data=product['id']))
if page_number != 0:
keyboard.add(
InlineKeyboardButton('← Пред. стр.',
callback_data=f'pagination,{page_number-1}'))
if last_product_num < len(products) and page_number != 0:
keyboard.insert(
InlineKeyboardButton('След. стр. →',
callback_data=f'pagination,{page_number+1}'))
if last_product_num < len(products) and page_number == 0:
keyboard.add(
InlineKeyboardButton('След. стр. →',
callback_data=f'pagination,{page_number+1}'))
keyboard.add(CART_BUTTON)
tg_logger.debug('Menu keyboard was collected')
return keyboard
async def scheduled(wait_for):
while True:
await asyncio.sleep(wait_for)
# проверяем наличие новых игр
new_publication = rt.new_publication()
if new_publication:
subscriptions = db.get_subscriptions()
keyboard = InlineKeyboardMarkup(row_width=2)
keyboard.insert(
InlineKeyboardButton(text="👍 0",
callback_data=like.new(action=1)))
keyboard.insert(
InlineKeyboardButton(text="👎 0",
callback_data=like.new(action=0)))
# отправляем всем новость
for s in subscriptions:
await bot.send_photo(s[1],
new_publication['url_photo'],
caption=('[Смотреть]({0})'.format(
new_publication['link'])),
disable_notification=True,
parse_mode='MarkdownV2',
reply_markup=keyboard)
# добовляем пост в базу и ставить статус, что опубликован
db.add_publication(new_publication['id'], status=True)
