async def alive_function(answers):
buttons = InlineKeyboard(row_width=2)
bot_state = 'Dead' if not await app.get_me() else 'Alive'
ubot_state = 'Dead' if not await app2.get_me() else 'Alive'
buttons.add(
InlineKeyboardButton(
'Stats',
callback_data='stats_callback'
),
InlineKeyboardButton(
"Go Inline!",
switch_inline_query_current_chat=""
)
)
msg = f"""
**[William✨](https://github.com/thehamkercat/WilliamButcherBot):**
**MainBot:** `{bot_state}`
**UserBot:** `{ubot_state}`
**Python:** `{pyver.split()[0]}`
**Pyrogram:** `{pyrover}`
**MongoDB:** `{mongover}`
**Platform:** `{sys.platform}`
**Profiles:** [BOT](t.me/{BOT_USERNAME}) | [UBOT](t.me/{USERBOT_USERNAME})
"""
answers.append(
InlineQueryResultArticle(
title='Alive',
description="Check Bot's Stats",
thumb_url="https://static2.aniimg.com/upload/20170515/414/c/d/7/cd7EEF.jpg",
input_message_content=InputTextMessageContent(
msg,
disable_web_page_preview=True
),
reply_markup=buttons,
)
)
return answers
async def inline_help_func(__HELP__):
buttons = InlineKeyboard(row_width=2)
buttons.add(
InlineKeyboardButton(
'Get More Help.',
url=f"t.me/{BOT_USERNAME}?start=start"
),
InlineKeyboardButton(
"Go Inline!",
switch_inline_query_current_chat=""
)
)
answerss = [
InlineQueryResultArticle(
title="Inline Commands",
description="Help Related To Inline Usage.",
input_message_content=InputTextMessageContent(__HELP__),
thumb_url="https://hamker.me/cy00x5x.png",
reply_markup=buttons
)
]
answerss = await alive_function(answerss)
return answerss
async def speedtest_init(query):
answers = []
user_id = query.from_user.id
if user_id not in SUDOERS:
msg = "**ERROR**\n__THIS FEATURE IS ONLY FOR SUDO USERS__"
answers.append(
InlineQueryResultArticle(
title="ERROR",
description="THIS FEATURE IS ONLY FOR SUDO USERS",
input_message_content=InputTextMessageContent(msg),
))
return answers
msg = "**Click The Button Below To Perform A Speedtest**"
button = InlineKeyboard(row_width=1)
button.add(
InlineKeyboardButton(text="Test", callback_data="test_speedtest"))
answers.append(
InlineQueryResultArticle(
title="Click Here",
input_message_content=InputTextMessageContent(msg),
reply_markup=button,
))
return answers
def petardi(_, message):
if message.chat.id not in chatScommesse:
message.reply("Gruppo non abilitato, contatta @Anatras02 se credi si tratti di un errore")
return
utente = str(message.from_user.id)
codice = codice_func()
keyboard = InlineKeyboard(row_width=1)
keyboard.add(
InlineKeyboardButton("Lancia 💣", callback_data=f"lancia|{utente}|{codice}"),
InlineKeyboardButton("Cancella ❌", callback_data=f"cancella|{utente}|{codice}")
)
tiratori_petardi[f"{utente}{codice}"] = dict()
tiratori_petardi[f"{utente}{codice}"]["terminato"] = False
tiratori_petardi[f"{utente}{codice}"]["risultati"] = []
message.reply(
f"{message.from_user.first_name} sei abbastanza na🅱️oletano da rischiare le dita per un po' di divertimento?",
reply_markup=keyboard,
quote=False
)
async def inline_help_func(__HELP__):
buttons = InlineKeyboard(row_width=3)
keywords_list = [
"alive", "ping", "tr", "ud", "google", "bitly",
"wall", "yt", "torrent", "lyrics", "wiki",
"speedtest", "music", "saavn", "deezer",
"gh_repo", "gh_user", "search", "pastebin",
"nsfw_scan", "ytmusic", "carbon", "info"
]
buttons.add(*[(InlineKeyboardButton(
text=i, switch_inline_query_current_chat=i)) for i in keywords_list])
answerss = [
InlineQueryResultArticle(
title="Inline Commands",
description="Help Related To Inline Usage.",
input_message_content=InputTextMessageContent(
"Click A Button To Get Started."),
thumb_url="https://hamker.me/cy00x5x.png",
reply_markup=buttons
)
]
answerss = await alive_function(answerss)
return answerss
async def un_auth(_, message):
if message.chat.id is AdminSettings:
return
msg = f"""
Hi {message.chat.first_name},
You must be looking forward on how I work.
In that case I can give you helpful links to self host me on your own.
Here are some links for you
"""
buttons = InlineKeyboard(row_width=2)
buttons.add(
InlineKeyboardButton(
'Documentation',
url='https://t.me/SkinoidBot',
),
InlineKeyboardButton(
'Repository',
url='https://github.com/TeamEviral/Skynoid',
),
InlineKeyboardButton('Support', url='https://t.me/SkynoidSupport'),
)
await message.reply(msg, reply_markup=buttons)
async def carbon_inline_func(answers, link):
link = link.split("/")
if link[3] == "c":
chat, message_id = int("-100" + link[4]), int(link[5])
else:
chat, message_id = link[3], link[4]
m = await app.get_messages(chat, message_ids=int(message_id))
if not m.text and not m.document:
m = await app2.get_messages(chat, message_ids=int(message_id))
if m.text:
content = m.text
else:
if m.document.file_size > 1048576:
answers.append(
InlineQueryResultArticle(
title="DOCUMENT TOO BIG",
description="Maximum supported size is 1MB",
input_message_content=InputTextMessageContent(
"DOCUMENT TOO BIG"),
))
return answers
doc = await m.download()
async with aiofiles.open(doc, mode="r") as f:
content = await f.read()
os.remove(doc)
image = await make_carbon(content)
link = await paste(content)
# To Pre-cache the media
carbon = await app.send_document(MESSAGE_DUMP_CHAT, image)
os.remove(image)
buttons = InlineKeyboard(row_width=1)
buttons.add(InlineKeyboardButton(text="Paste Link", url=link))
answers.append(
InlineQueryResultCachedDocument(file_id=carbon.document.file_id,
title="Carbon",
reply_markup=buttons))
return answers
async def youtube_func(answers, text):
results = await arq.youtube(text)
if not results.ok:
answers.append(
InlineQueryResultArticle(
title="Error",
description=results.result,
input_message_content=InputTextMessageContent(results.result),
))
return answers
limit = 0
results = results.result
for i in results:
if limit > 48:
break
limit += 1
buttons = InlineKeyboard(row_width=1)
video_url = f"https://youtube.com{i.url_suffix}"
buttons.add(InlineKeyboardButton("Watch", url=video_url))
caption = f"""
**Title:** {i.title}
**Views:** {i.views}
**Channel:** {i.channel}
**Duration:** {i.duration}
**Uploaded:** {i.publish_time}
**Description:** {i.long_desc}"""
description = f"{i.views} | {i.channel} | " + f"{i.duration} | {i.publish_time}"
answers.append(
InlineQueryResultArticle(
title=i.title,
thumb_url=i.thumbnails[0],
description=description,
input_message_content=InputTextMessageContent(
caption, disable_web_page_preview=True),
reply_markup=buttons,
))
return answers
async def saavn_func(answers, text):
buttons_list = []
results = await arq.saavn(text)
if not results.ok:
answers.append(
InlineQueryResultArticle(
title="Error",
description=results.result,
input_message_content=InputTextMessageContent(results.result),
)
)
return answers
results = results.result
for count, i in enumerate(results):
buttons = InlineKeyboard(row_width=1)
buttons.add(InlineKeyboardButton("Download | Play", url=i.media_url))
buttons_list.append(buttons)
duration = await time_convert(i.duration)
caption = f"""
**Title:** {i.song}
**Album:** {i.album}
**Duration:** {duration}
**Release:** {i.year}
**Singers:** {i.singers}"""
description = f"{i.album} | {duration} " + f"| {i.singers} ({i.year})"
answers.append(
InlineQueryResultArticle(
title=i.song,
input_message_content=InputTextMessageContent(
caption, disable_web_page_preview=True
),
description=description,
thumb_url=i.image,
reply_markup=buttons_list[count],
)
)
return answers
async def youtube_func(answers, text):
buttons_list = []
results = await arq.youtube(text)
for i in results:
buttons = InlineKeyboard(row_width=1)
video_url = f"https://youtube.com{results[i].url_suffix}"
buttons.add(
InlineKeyboardButton(
'Watch',
url=video_url
)
)
buttons_list.append(buttons)
caption = f"""
**Title:** {results[i].title}
**Views:** {results[i].views}
**Channel:** {results[i].channel}
**Duration:** {results[i].duration}
**Uploaded:** {results[i].publish_time}
**Description:** {results[i].long_desc}"""
description = f"{results[i].views} | {results[i].channel} | " \
+ f"{results[i].duration} | {results[i].publish_time}"
try:
answers.append(
InlineQueryResultArticle(
title=results[i].title,
thumb_url=results[i].thumbnails[0],
description=description,
input_message_content=InputTextMessageContent(
caption,
disable_web_page_preview=True
),
reply_markup=buttons_list[i]
))
except (KeyError, ValueError):
pass
return answers
async def inline_help_func(__HELP__):
buttons = InlineKeyboard(row_width=4)
buttons.add(
*[(InlineKeyboardButton(text=i, switch_inline_query_current_chat=i))
for i in keywords_list])
answerss = [
InlineQueryResultArticle(
title="Inline Commands",
description="Help Related To Inline Usage.",
input_message_content=InputTextMessageContent(
"Click A Button To Get Started."),
thumb_url="https://hamker.me/cy00x5x.png",
reply_markup=buttons,
),
InlineQueryResultArticle(
title="Github Repo",
description="Get Github Respository Of Bot.",
input_message_content=InputTextMessageContent(
"https://github.com/thehamkercat/WilliamButcherBot"),
thumb_url="https://hamker.me/gjc9fo3.png",
),
]
answerss = await alive_function(answerss)
return answerss
async def github_user_func(answers, text):
URL = f"https://api.github.com/users/{text}"
result = await fetch(URL)
buttons = InlineKeyboard(row_width=1)
buttons.add(
InlineKeyboardButton(text="Open On Github",
url=f"https://github.com/{text}"))
caption = f"""
**Info Of {result['name']}**
**Username:** `{text}`
**Bio:** `{result['bio']}`
**Profile Link:** [Here]({result['html_url']})
**Company:** `{result['company']}`
**Created On:** `{result['created_at']}`
**Repositories:** `{result['public_repos']}`
**Blog:** `{result['blog']}`
**Location:** `{result['location']}`
**Followers:** `{result['followers']}`
**Following:** `{result['following']}`"""
answers.append(
InlineQueryResultPhoto(photo_url=result["avatar_url"],
caption=caption,
reply_markup=buttons))
return answers
async def deezer_func(answers, text):
buttons_list = []
results = await arq.deezer(text, 5)
if not results.ok:
answers.append(
InlineQueryResultArticle(
title="Error",
description=results.result,
input_message_content=InputTextMessageContent(results.result),
)
)
return answers
results = results.result
for count, i in enumerate(results):
buttons = InlineKeyboard(row_width=1)
buttons.add(InlineKeyboardButton("Download | Play", url=i.url))
buttons_list.append(buttons)
duration = await time_convert(i.duration)
caption = f"""
**Title:** {i.title}
**Artist:** {i.artist}
**Duration:** {duration}
**Source:** [Deezer]({i.source})"""
description = f"{i.artist} | {duration}"
answers.append(
InlineQueryResultArticle(
title=i.title,
thumb_url=i.thumbnail,
description=description,
input_message_content=InputTextMessageContent(
caption, disable_web_page_preview=True
),
reply_markup=buttons_list[count],
)
)
return answers
async def saavn_func(answers, text):
buttons_list = []
results = await arq.saavn(text)
for i in results:
buttons = InlineKeyboard(row_width=1)
buttons.add(
InlineKeyboardButton(
'Download | Play',
url=results[i].media_url
)
)
buttons_list.append(buttons)
duration = await time_convert(results[i].duration)
caption = f"""
**Title:** {results[i].song}
**Album:** {results[i].album}
**Duration:** {duration}
**Release:** {results[i].year}
**Singers:** {results[i].singers}"""
description = f"{results[i].album} | {duration} " \
+ f"| {results[i].singers} ({results[i].year})"
try:
answers.append(
InlineQueryResultArticle(
title=results[i].song,
input_message_content=InputTextMessageContent(
caption,
disable_web_page_preview=True
),
description=description,
thumb_url=results[i].image,
reply_markup=buttons_list[i]
))
except (KeyError, ValueError):
pass
return answers
async def inline_help_func(__HELP__):
buttons = InlineKeyboard(row_width=4)
buttons.add(
*[(InlineKeyboardButton(text=i, switch_inline_query_current_chat=i))
for i in keywords_list])
answerss = [
InlineQueryResultArticle(
title="Inline Commands",
description="Help Related To Inline Usage.",
input_message_content=InputTextMessageContent(
"Click A Button To Get Started."),
thumb_url="https://telegra.ph/file/7ee7b8ea4b6955642aa2e.jpg",
reply_markup=buttons,
),
InlineQueryResultArticle(
title="Github Repo",
description="Get Github Respository Of Bot.",
input_message_content=InputTextMessageContent(
"https://github.com/TeamInnexia"),
thumb_url="https://telegra.ph/file/36d8e6e3d7849e7e8d396.jpg",
),
]
answerss = await alive_function(answerss)
return answerss
thumb_url=results[i].url_thumb,
caption=f"[Source]({results[i].url_image})"
))
except KeyError:
pass
return answers
async def saavn_func(answers, text):
buttons_list = []
results = await arq.saavn(text)
for i in results:
buttons = InlineKeyboard(row_width=1)
buttons.add(
InlineKeyboardButton(
'Download | Play',
url=results[i].media_url
)
)
buttons_list.append(buttons)
duration = await time_convert(results[i].duration)
caption = f"""
**Title:** {results[i].song}
**Album:** {results[i].album}
**Duration:** {duration}
**Release:** {results[i].year}
**Singers:** {results[i].singers}"""
description = f"{results[i].album} | {duration} " \
+ f"| {results[i].singers} ({results[i].year})"
try:
answers.append(
InlineQueryResultArticle(
def lancia_query(app, callback_query):
frasi_effetto_successo = [
"Hai lanciato un petardo all'ultimo, non sei morto ma hai fatto saltare **{punti}** dita a {giocatore}",
"Hai lanciato il petardo ma non è scoppiato, nel dubbio scommetti con dod1c1 il frosciu e vinci "
"**{punti}**kkk ",
"Lanci un petardo in un cimitero a Napoli, TwisterHDD e il sindaco ti incominciano ad inseguire.\nPerdi "
"**{punti}** anni di vita ",
"Lanci un petardo in taverna, Edo ti muta per **{punti}** giorni",
"Dopo aver tirato un petardo Edo spaventato esce da dietro un albero avvolto in un impermeabile grigio, "
"lo apre di scatto e ti mostra il pene, esclami: \"Che bel pisello da **{punti}**cm\"",
"Lanci un petardo al grido di \"DRICER SEI UN TESTA DI CAZZO\", Dricer arriva e ti rompe **{punti}** "
"costole",
"Lanci un petardo ma quest’ultimo non scoppia, dod1c1 deluso ti dissa **{punti}** volte in un freestyle"
]
frasi_effetto_perdita = [
"Ti scoppia un petardo in mano, perdi tutte le dita della mano!\nSei costretto a scappare in pronto "
"soccorso",
]
codice = callback_query.data.split("|")[2]
utente = int(callback_query.data.split("|")[1])
tag_utente = f"{utente}{codice}"
try:
tiratori_petardi[tag_utente]
except KeyError:
callback_query.answer("Il bot è stato riavviato mentre giocavi, rilancia il comando /petardi")
return
if callback_query.from_user.id != utente:
callback_query.answer("Eh, volevi!")
return
keyboard = InlineKeyboard(row_width=1)
keyboard.add(
InlineKeyboardButton("Lancia 💣", callback_data=f"lancia|{utente}|{codice}"),
InlineKeyboardButton("Termina ❌", callback_data=f"termina|{utente}|{codice}")
)
numero_lanci = len(tiratori_petardi[tag_utente]["risultati"])
if numero_lanci == 1:
probabilità = 5
elif numero_lanci == 2:
probabilità = 7
elif numero_lanci == 3:
if random.randint(1, 100) < 20:
probabilità = 30
else:
probabilità = 10
elif numero_lanci == 4:
probabilità = 15
elif numero_lanci == 5:
probabilità = random.randint(15, 25)
elif numero_lanci == 6:
probabilità = random.randint(20, 35)
elif 6 < numero_lanci <= 10:
probabilità = random.randint(30, 40)
elif 10 < numero_lanci < 20:
probabilità = random.randint(35, 60)
else:
probabilità = random.randint(75, 100)
if not tiratori_petardi[tag_utente]["terminato"] and \
(not tiratori_petardi[tag_utente]["risultati"] or random.randint(1, 100) >= probabilità):
numero = random.randint(1, 25)
giocatore_random_var = giocatore_random(utente, callback_query.message.chat.id, app)
frase = random.choice(frasi_effetto_successo).format(punti="__[REDACTED]__", giocatore=giocatore_random_var)
tiratori_petardi[tag_utente]["risultati"].append(numero)
counter = 1
tiri = f"{frase}\n\n"
for _ in tiratori_petardi[tag_utente]["risultati"]:
tiri += f"**Punteggio {counter}:** [__REDACTED__]\n"
counter += 1
try:
callback_query.edit_message_text(
tiri,
reply_markup=keyboard
)
time.sleep(0.1)
except FloodWait:
callback_query.answer("Sì ma stai calmo dio cane")
else:
keyboard = InlineKeyboard(row_width=1)
keyboard.add(
InlineKeyboardButton("Mostra Punteggi ✌️", callback_data=f"punteggio|{utente}|{codice}|F"),
)
tiratori_petardi[tag_utente]["terminato"] = True
frase = random.choice(frasi_effetto_perdita)
frase += f"\n\nIl petardo ti è esploso al turno numero **{numero_lanci + 1}**"
callback_query.edit_message_text(
frase,
reply_markup=keyboard
)
async def pm_button(client, query):
print(query)
if not PM_PERMIT:
return
if (query.from_user.id in AdminSettings
and not re.match('engine_pm_apr', query.data)
and not re.match('engine_pm_blk', query.data)):
await client.answer_callback_query(
query.id,
"You shouln't click this.",
show_alert=False,
)
return
if re.match('engine_pm_block', query.data):
await app.send_sticker(
query.from_user.id,
sticker='CAADAgAD1QQAAp7kTAry1JrL3zVXSxYE',
)
await setbot.edit_inline_text(
query.from_user.id,
'Sorry, no cash for today.\nGoodbye!',
)
await app.block_user(query.from_user.id)
elif re.match('engine_pm_nope', query.data):
await setbot.edit_inline_text(query.inline_message_id, '👍')
await app.send_message(
query.from_user.id,
'Hello, please wait for a reply from my master, thank you.',
)
buttons = InlineKeyboard(row_width=2)
buttons.add(
InlineKeyboardButton(
'Approve',
callback_data=f'engine_pm_apr-{query.from_user.id}',
),
InlineKeyboardButton(
'Block',
callback_data=f'engine_pm_blk-{query.from_user.id}',
),
)
pm_bot_mention = mention_markdown(
query.from_user.id,
query.from_user.first_name,
)
pm_bot_message = f'~{pm_bot_mention} want to contact you~'
await setbot.send_message(
NOTIFY_ID,
pm_bot_message,
reply_markup=buttons,
)
set_req(query.from_user.id, True)
elif re.match('engine_pm_report', query.data):
await setbot.edit_inline_text(query.inline_message_id, '👍')
await app.send_message(
query.from_user.id,
'Hello, if you want to report any bugs, visit @NanaBotSupport.',
)
elif re.match('engine_pm_none', query.data):
await setbot.edit_inline_text(query.inline_message_id, '👍')
await app.send_message(
query.from_user.id,
'Alright then',
)
elif re.match('engine_pm_apr', query.data):
target = query.data.split('-')[1]
await query.message.edit_text(f'[Approved to PM]({target})')
await app.send_message(
target,
'Hello, this is **Nana**, my master approved you to PM.',
)
set_whitelist(int(target), True)
elif re.match(r'engine_pm_blk', query.data):
target = query.data.split('-')[1]
await query.message.edit_text('That user was blocked ~')
await app.send_message(
target,
'Hello, you have been blocked.\nSorry about this!',
)
await app.block_user(target)
else:
await setbot.edit_inline_text(query.inline_message_id, '🙆')
def tira_query(app, callback_query):
if "tira" in callback_query.data:
frasi_effetto = [
"Hai lanciato una **freccia** che è andata **{punti}** metri lontana",
"Con una sola **freccia** sei riuscito ad uccidere ben **{punti}** uccellini in volo",
"**{giocatore}** ti fa incazzare, dalla rabbia gli spari **{punti}** frecce sul petto "
"lasciandolo a terra stecchito",
'**Edo ⚡️** viene da te e con aria soddisfatta ti dice __Haha, sono il dio supremo__\nDalla '
'rabbia gli tiri una freccia che gli leva **{punti}** punti vita!',
"Non hai tempo di tirare fuori la freccia, prendi l'arco e lo **spacchi in testa** a **{"
"giocatore}** provocandogli **{punti}** danni",
"Sbagli a lanciare la freccia e **ti colpisci un piede**, incomici a bestemmiare "
"**selvaggemente**\nDio scende in terra **incazzato** perché gli hai levato **{punti}** punti "
"vita",
"@dod1c1 spara {punti} frecce a @tdjj05 su una di queste è scalfito il messaggio \"DRICER SEI "
"UN TESTA DI CAZZO\""
]
codice = callback_query.data.split("|")[2]
utente = int(callback_query.data.split("|")[1])
tag_utente = f"{utente}{codice}"
try:
tiratori_tca[tag_utente]
except KeyError:
callback_query.answer(
"Il bot è stato riavviato mentre giocavi, rilancia il comando /tca"
)
return
if callback_query.from_user.id != utente:
callback_query.answer("Eh, volevi!")
return
numero = random.randint(1, 25)
giocatore_random_var = giocatore_random(utente,
callback_query.message.chat.id,
app)
frase = random.choice(frasi_effetto).format(
punti=numero, giocatore=giocatore_random_var)
tiratori_tca[tag_utente]["risultati"].append(numero)
keyboard = InlineKeyboard(row_width=1)
keyboard.add(
InlineKeyboardButton("Tira 🏹",
callback_data=f"tira|{utente}|{codice}"))
counter = 1
tiri = ""
for tiro in tiratori_tca[tag_utente]["risultati"]:
tiri += f"**Tiro {counter}:** __{tiro}__\n"
counter += 1
if counter > 3:
giocatore = app.get_users(utente).first_name
tot_punti = sum(tiratori_tca[tag_utente]["risultati"])
if tot_punti < 15:
commento = "(un po' una merda)"
elif tot_punti < 40:
commento = "(meh)"
elif tot_punti < 50:
commento = "(incominciamo a ragionare)"
elif tot_punti < 60:
commento = "(bella giocata)"
elif tot_punti < 75:
commento = "(non vantarti, è solo culo)"
elif tot_punti == 75:
commento = "(hai barato ammettilo!)"
else:
commento = ""
callback_query.edit_message_text(
f"Tiri un' ultima __freccia potentissima__ verso il cielo superando i __confini dell'universo__ che "
f"ti conferisce **{numero}** punti!\n\nBeh che dire **{giocatore}**, hai distrutto l'universo per "
f"divertirti un po' ma nel mentre hai totalizzato **{tot_punti}** punti\n\n**__Questi sono stati i "
f"tuoi tiri__** {commento}\n{tiri}\n**Totale:** {tot_punti} ")
setta_scommessa(callback_query.from_user, "Tiro con l'arco",
tot_punti)
else:
if counter > 3:
callback_query.edit_message_text(
f"Contano solo i primi 3 tiri!\nNon cheatare mai più o ban!\n\n**__Questi infatti sono stati i "
f"tuoi tiri__**\n{tiri} ")
else:
callback_query.edit_message_text(f"{frase}\n\n{tiri}",
reply_markup=keyboard)
tiratori_tca[tag_utente]["tiro"] += 1
elif "Cancella" in callback_query.data:
utente = callback_query.data.split("|")[1]
if callback_query.from_user.id != int(utente):
callback_query.answer("Non si può più, F!")
return
callback_query.edit_message_text("Tiro annullato 😢")
async def anime_func(string, answers):
json = (await
anime_sauce(string.split(None,
1)[1], ))['data'].get('Media', None)
if json:
msg = ('**{}** (`{}`)\n'
'**Type**: {}\n'
'**Status**: {}\n'
'**Episodes**: {}\n'
'**Duration**: {}'
'Per Ep.\n**Score**: {}\n**Genres**: `').format(
json['title']['romaji'],
json['title']['native'],
json['format'],
json['status'],
json.get('episodes', 'N/A'),
json.get('duration', 'N/A'),
json['averageScore'],
)
for x in json['genres']:
msg += f'{x}, '
msg = msg[:-2] + '`\n'
msg += '**Studios**: `'
for x in json['studios']['nodes']:
msg += f"{x['name']}, "
msg = msg[:-2] + '`\n'
info = json.get('siteUrl')
trailer = json.get('trailer', None)
if trailer:
trailer_id = trailer.get('id', None)
site = trailer.get('site', None)
if site == 'youtube':
trailer = 'https://youtu.be/' + trailer_id
description = (json.get('description', 'N/A').replace(
'<i>', '').replace('</i>', '').replace('<br>', ''))
msg += shorten(description, info)
image = f'https://img.anili.st/media/{json["id"]}'
buttons = InlineKeyboard(row_width=2)
if trailer:
buttons.add(InlineKeyboardButton('Trailer 🎬', url=trailer), )
buttons.add(
InlineKeyboardButton('More Info', url=info),
InlineKeyboardButton(
'Add to Watchlist',
callback_data=f'addfav_{json["title"]["romaji"]}',
),
)
if image:
answers.append(
InlineQueryResultPhoto(
caption=msg,
photo_url=image,
parse_mode='markdown',
title=f"{json['title']['romaji']}",
description=f"{json['format']}",
reply_markup=buttons,
), )
else:
answers.append(
InlineQueryResultArticle(
title=f"{json['title']['romaji']}",
description=f"{json['averageScore']}",
input_message_content=InputTextMessageContent(
msg,
parse_mode='markdown',
disable_web_page_preview=True,
),
reply_markup=buttons,
), )
async def note_func(string, client, query, answers):
if len(string.split()) == 1:
allnotes = notes_db.get_all_selfnotes_inline(query.from_user.id)
if not allnotes:
await client.answer_inline_query(
query.id,
results=answers,
switch_pm_text='You dont have any notes!',
switch_pm_parameter='help_inline',
)
return
rng = min(len(list(allnotes)), 30)
for x in range(rng):
note = allnotes[list(allnotes)[x]]
noteval = note['value']
notetype = note['type']
# notefile = note["file"]
if notetype != Types.TEXT:
continue
note, button = parse_button(noteval)
button = build_keyboard(button)
answers.append(
InlineQueryResultArticle(
title='Note #{}'.format(list(allnotes)[x]),
description=note,
input_message_content=InputTextMessageContent(note),
reply_markup=InlineKeyboardMarkup(button),
),
)
await client.answer_inline_query(
query.id,
results=answers,
switch_pm_text='Yourself notes',
switch_pm_parameter='help_inline',
)
return
q = string.split(None, 1)
notetag = q[1]
noteval = notes_db.get_selfnote(query.from_user.id, notetag)
if not noteval:
await client.answer_inline_query(
query.id,
results=answers,
switch_pm_text='Note not found!',
switch_pm_parameter='help_inline',
)
return
note, button = parse_button(noteval.get('value'))
button = build_keyboard(button)
answers.append(
InlineQueryResultArticle(
title=f'Note #{notetag}',
description=note,
input_message_content=InputTextMessageContent(note),
reply_markup=InlineKeyboardMarkup(button),
),
)
try:
await client.answer_inline_query(
query.id,
results=answers,
cache_time=5,
)
except errors.exceptions.bad_request_400.MessageEmpty:
exc_type, exc_obj, exc_tb = sys.exc_info()
log_errors = traceback.format_exception(
etype=exc_type, value=exc_obj, tb=exc_tb,
)
button = InlineKeyboard(row_width=1)
button.add(
InlineKeyboardButton(
'🐞 Report bugs',
callback_data='report_errors',
),
)
text = 'An error has accured!\n\n```{}```\n'.format(
''.join(log_errors),
)
await setbot.send_message(Owner, text, reply_markup=button)
