# <============================================== IMPORTS =========================================================> import asyncio import json import logging import os import random import re import shlex import time from datetime import datetime from os.path import basename from time import time from traceback import format_exc as err from typing import Optional, Tuple from urllib.parse import quote from uuid import uuid4 import requests import urllib3 from bs4 import BeautifulSoup from motor.core import AgnosticClient, AgnosticCollection, AgnosticDatabase from motor.motor_asyncio import AsyncIOMotorClient from pyrogram import Client, filters from pyrogram.enums import ChatMemberStatus, ChatType from pyrogram.errors import ( FloodWait, MessageNotModified, UserNotParticipant, WebpageCurlFailed, WebpageMediaEmpty, ) from pyrogram.types import ( CallbackQuery, InlineKeyboardButton, InlineKeyboardMarkup, InputMediaPhoto, Message, ) from Mikobot import BOT_USERNAME, MESSAGE_DUMP, MONGO_DB_URI, app from Mikobot.utils.custom_filters import PREFIX_HANDLER # <=======================================================================================================> FILLERS = {} BOT_OWNER = list({int(x) for x in ("7480891683").split()}) _MGCLIENT: AgnosticClient = AsyncIOMotorClient(MONGO_DB_URI) _DATABASE: AgnosticDatabase = _MGCLIENT["MikobotAnime"] def get_collection(name: str) -> AgnosticCollection: """Create or Get Collection from your database""" return _DATABASE[name] def _close_db() -> None: _MGCLIENT.close() GROUPS = get_collection("GROUPS") SFW_GRPS = get_collection("SFW_GROUPS") DC = get_collection("DISABLED_CMDS") AG = get_collection("AIRING_GROUPS") CG = get_collection("CRUNCHY_GROUPS") SG = get_collection("SUBSPLEASE_GROUPS") HD = get_collection("HEADLINES_GROUPS") MHD = get_collection("MAL_HEADLINES_GROUPS") CHAT_OWNER = ChatMemberStatus.OWNER MEMBER = ChatMemberStatus.MEMBER ADMINISTRATOR = ChatMemberStatus.ADMINISTRATOR failed_pic = "https://telegra.ph/file/09733b49f3a9d5b147d21.png" no_pic = [ "https://telegra.ph/file/0d2097f442e816ba3f946.jpg", "https://telegra.ph/file/5a152016056308ef63226.jpg", "https://telegra.ph/file/d2bf913b18688c59828e9.jpg", "https://telegra.ph/file/d53083ea69e84e3b54735.jpg", "https://telegra.ph/file/b5eb1e3606b7d2f1b491f.jpg", ] DOWN_PATH = "Mikobot/downloads/" AUTH_USERS = get_collection("AUTH_USERS") IGNORE = get_collection("IGNORED_USERS") PIC_DB = get_collection("PIC_DB") GROUPS = get_collection("GROUPS") CC = get_collection("CONNECTED_CHANNELS") USER_JSON = {} USER_WC = {} LANGUAGES = { "af": "afrikaans", "sq": "albanian", "am": "amharic", "ar": "arabic", "hy": "armenian", "az": "azerbaijani", "eu": "basque", "be": "belarusian", "bn": "bengali", "bs": "bosnian", "bg": "bulgarian", "ca": "catalan", "ceb": "cebuano", "ny": "chichewa", "zh-cn": "chinese (simplified)", "zh-tw": "chinese (traditional)", "co": "corsican", "hr": "croatian", "cs": "czech", "da": "danish", "nl": "dutch", "en": "english", "eo": "esperanto", "et": "estonian", "tl": "filipino", "fi": "finnish", "fr": "french", "fy": "frisian", "gl": "galician", "ka": "georgian", "de": "german", "el": "greek", "gu": "gujarati", "ht": "haitian creole", "ha": "hausa", "haw": "hawaiian", "iw": "hebrew", "he": "hebrew", "hi": "hindi", "hmn": "hmong", "hu": "hungarian", "is": "icelandic", "ig": "igbo", "id": "indonesian", "ga": "irish", "it": "italian", "ja": "japanese", "jw": "javanese", "kn": "kannada", "kk": "kazakh", "km": "khmer", "ko": "korean", "ku": "kurdish (kurmanji)", "ky": "kyrgyz", "lo": "lao", "la": "latin", "lv": "latvian", "lt": "lithuanian", "lb": "luxembourgish", "mk": "macedonian", "mg": "malagasy", "ms": "malay", "ml": "malayalam", "mt": "maltese", "mi": "maori", "mr": "marathi", "mn": "mongolian", "my": "myanmar (burmese)", "ne": "nepali", "no": "norwegian", "or": "odia", "ps": "pashto", "fa": "persian", "pl": "polish", "pt": "portuguese", "pa": "punjabi", "ro": "romanian", "ru": "russian", "sm": "samoan", "gd": "scots gaelic", "sr": "serbian", "st": "sesotho", "sn": "shona", "sd": "sindhi", "si": "sinhala", "sk": "slovak", "sl": "slovenian", "so": "somali", "es": "spanish", "su": "sundanese", "sw": "swahili", "sv": "swedish", "tg": "tajik", "ta": "tamil", "tt": "tatar", "te": "telugu", "th": "thai", "tr": "turkish", "tk": "turkmen", "uk": "ukrainian", "ur": "urdu", "ug": "uyghur", "uz": "uzbek", "vi": "vietnamese", "cy": "welsh", "xh": "xhosa", "yi": "yiddish", "yo": "yoruba", "zu": "zulu", } DEFAULT_SERVICE_URLS = ( "translate.google.ac", "translate.google.ad", "translate.google.ae", "translate.google.al", "translate.google.am", "translate.google.as", "translate.google.at", "translate.google.az", "translate.google.ba", "translate.google.be", "translate.google.bf", "translate.google.bg", "translate.google.bi", "translate.google.bj", "translate.google.bs", "translate.google.bt", "translate.google.by", "translate.google.ca", "translate.google.cat", "translate.google.cc", "translate.google.cd", "translate.google.cf", "translate.google.cg", "translate.google.ch", "translate.google.ci", "translate.google.cl", "translate.google.cm", "translate.google.cn", "translate.google.co.ao", "translate.google.co.bw", "translate.google.co.ck", "translate.google.co.cr", "translate.google.co.id", "translate.google.co.il", "translate.google.co.in", "translate.google.co.jp", "translate.google.co.ke", "translate.google.co.kr", "translate.google.co.ls", "translate.google.co.ma", "translate.google.co.mz", "translate.google.co.nz", "translate.google.co.th", "translate.google.co.tz", "translate.google.co.ug", "translate.google.co.uk", "translate.google.co.uz", "translate.google.co.ve", "translate.google.co.vi", "translate.google.co.za", "translate.google.co.zm", "translate.google.co.zw", "translate.google.co", "translate.google.com.af", "translate.google.com.ag", "translate.google.com.ai", "translate.google.com.ar", "translate.google.com.au", "translate.google.com.bd", "translate.google.com.bh", "translate.google.com.bn", "translate.google.com.bo", "translate.google.com.br", "translate.google.com.bz", "translate.google.com.co", "translate.google.com.cu", "translate.google.com.cy", "translate.google.com.do", "translate.google.com.ec", "translate.google.com.eg", "translate.google.com.et", "translate.google.com.fj", "translate.google.com.gh", "translate.google.com.gi", "translate.google.com.gt", "translate.google.com.hk", "translate.google.com.jm", "translate.google.com.kh", "translate.google.com.kw", "translate.google.com.lb", "translate.google.com.lc", "translate.google.com.ly", "translate.google.com.mm", "translate.google.com.mt", "translate.google.com.mx", "translate.google.com.my", "translate.google.com.na", "translate.google.com.ng", "translate.google.com.ni", "translate.google.com.np", "translate.google.com.om", "translate.google.com.pa", "translate.google.com.pe", "translate.google.com.pg", "translate.google.com.ph", "translate.google.com.pk", "translate.google.com.pr", "translate.google.com.py", "translate.google.com.qa", "translate.google.com.sa", "translate.google.com.sb", "translate.google.com.sg", "translate.google.com.sl", "translate.google.com.sv", "translate.google.com.tj", "translate.google.com.tr", "translate.google.com.tw", "translate.google.com.ua", "translate.google.com.uy", "translate.google.com.vc", "translate.google.com.vn", "translate.google.com", "translate.google.cv", "translate.google.cx", "translate.google.cz", "translate.google.de", "translate.google.dj", "translate.google.dk", "translate.google.dm", "translate.google.dz", "translate.google.ee", "translate.google.es", "translate.google.eu", "translate.google.fi", "translate.google.fm", "translate.google.fr", "translate.google.ga", "translate.google.ge", "translate.google.gf", "translate.google.gg", "translate.google.gl", "translate.google.gm", "translate.google.gp", "translate.google.gr", "translate.google.gy", "translate.google.hn", "translate.google.hr", "translate.google.ht", "translate.google.hu", "translate.google.ie", "translate.google.im", "translate.google.io", "translate.google.iq", "translate.google.is", "translate.google.it", "translate.google.je", "translate.google.jo", "translate.google.kg", "translate.google.ki", "translate.google.kz", "translate.google.la", "translate.google.li", "translate.google.lk", "translate.google.lt", "translate.google.lu", "translate.google.lv", "translate.google.md", "translate.google.me", "translate.google.mg", "translate.google.mk", "translate.google.ml", "translate.google.mn", "translate.google.ms", "translate.google.mu", "translate.google.mv", "translate.google.mw", "translate.google.ne", "translate.google.nf", "translate.google.nl", "translate.google.no", "translate.google.nr", "translate.google.nu", "translate.google.pl", "translate.google.pn", "translate.google.ps", "translate.google.pt", "translate.google.ro", "translate.google.rs", "translate.google.ru", "translate.google.rw", "translate.google.sc", "translate.google.se", "translate.google.sh", "translate.google.si", "translate.google.sk", "translate.google.sm", "translate.google.sn", "translate.google.so", "translate.google.sr", "translate.google.st", "translate.google.td", "translate.google.tg", "translate.google.tk", "translate.google.tl", "translate.google.tm", "translate.google.tn", "translate.google.to", "translate.google.tt", "translate.google.us", "translate.google.vg", "translate.google.vu", "translate.google.ws", ) log = logging.getLogger(__name__) log.addHandler(logging.NullHandler()) urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning) URLS_SUFFIX = [ re.search("translate.google.(.*)", url.strip()).group(1) for url in DEFAULT_SERVICE_URLS ] URL_SUFFIX_DEFAULT = "cn" def rand_key(): return str(uuid4())[:8] def control_user(func): async def wrapper(_, message: Message): msg = json.loads(str(message)) gid = msg["chat"]["id"] gidtype = msg["chat"]["type"] if gidtype in [ChatType.SUPERGROUP, ChatType.GROUP] and not ( await GROUPS.find_one({"_id": gid}) ): try: gidtitle = msg["chat"]["username"] except KeyError: gidtitle = msg["chat"]["title"] await GROUPS.insert_one({"_id": gid, "grp": gidtitle}) await clog( "Mikobot", f"Bot added to a new group\n\n{gidtitle}\nID: `{gid}`", "NEW_GROUP", ) try: user = msg["from_user"]["id"] except KeyError: user = msg["chat"]["id"] if await IGNORE.find_one({"_id": user}): return nut = time() if user not in BOT_OWNER: try: out = USER_JSON[user] if nut - out < 1.2: USER_WC[user] += 1 if USER_WC[user] == 3: await message.reply_text( ("Stop spamming bot!!!" + "\nElse you will be blacklisted"), ) await clog("Mikobot", f"UserID: {user}", "SPAM") if USER_WC[user] == 5: await IGNORE.insert_one({"_id": user}) await message.reply_text( ( "You have been exempted from using this bot " + "now due to spamming 5 times consecutively!!!" + "\nTo remove restriction plead to " + "@ProjectCodeXSupport" ) ) await clog("Mikobot", f"UserID: {user}", "BAN") return await asyncio.sleep(USER_WC[user]) else: USER_WC[user] = 0 except KeyError: pass USER_JSON[user] = nut try: await func(_, message, msg) except FloodWait as e: await asyncio.sleep(e.x + 5) except MessageNotModified: pass except Exception: e = err() reply_msg = None if func.__name__ == "trace_bek": reply_msg = message.reply_to_message try: await clog( "Mikobot", "Message:\n" + msg["text"] + "\n\n" + "```" + e + "```", "COMMAND", msg=message, replied=reply_msg, ) except Exception: await clog("Mikobot", e, "FAILURE", msg=message) return wrapper def check_user(func): async def wrapper(_, c_q: CallbackQuery): cq = json.loads(str(c_q)) user = cq["from_user"]["id"] if await IGNORE.find_one({"_id": user}): return cqowner_is_ch = False cqowner = cq["data"].split("_").pop() if "-100" in cqowner: cqowner_is_ch = True ccdata = await CC.find_one({"_id": cqowner}) if ccdata and ccdata["usr"] == user: user_valid = True else: user_valid = False if user in BOT_OWNER or user == int(cqowner): if user not in BOT_OWNER: nt = time() try: ot = USER_JSON[user] if nt - ot < 1.4: await c_q.answer( ("Stop spamming bot!!!\n" + "Else you will be blacklisted"), show_alert=True, ) await clog("Mikobot", f"UserID: {user}", "SPAM") except KeyError: pass USER_JSON[user] = nt try: await func(_, c_q, cq) except FloodWait as e: await asyncio.sleep(e.x + 5) except MessageNotModified: pass except Exception: e = err() reply_msg = None if func.__name__ == "tracemoe_btn": reply_msg = c_q.message.reply_to_message try: await clog( "Mikobot", "Callback:\n" + cq["data"] + "\n\n" + "```" + e + "```", "CALLBACK", cq=c_q, replied=reply_msg, ) except Exception: await clog("Mikobot", e, "FAILURE", cq=c_q) else: if cqowner_is_ch: if user_valid: try: await func(_, c_q, cq) except FloodWait as e: await asyncio.sleep(e.x + 5) except MessageNotModified: pass except Exception: e = err() reply_msg = None if func.__name__ == "tracemoe_btn": reply_msg = c_q.message.reply_to_message try: await clog( "Mikobot", "Callback:\n" + cq["data"] + "\n\n" + "```" + e + "```", "CALLBACK_ANON", cq=c_q, replied=reply_msg, ) except Exception: await clog("Mikobot", e, "FAILURE", cq=c_q) else: await c_q.answer( ( "No one can click buttons on queries made by " + "channels unless connected with /aniconnect!!!" ), show_alert=True, ) else: await c_q.answer( "Not your query!!!", show_alert=True, ) return wrapper async def media_to_image(client: app, message: Message, x: Message, replied: Message): if not (replied.photo or replied.sticker or replied.animation or replied.video): await x.edit_text("Media Type Is Invalid !") await asyncio.sleep(5) await x.delete() return media = replied.photo or replied.sticker or replied.animation or replied.video if not os.path.isdir(DOWN_PATH): os.makedirs(DOWN_PATH) dls = await client.download_media( media, file_name=DOWN_PATH + rand_key(), ) dls_loc = os.path.join(DOWN_PATH, os.path.basename(dls)) if replied.sticker and replied.sticker.file_name.endswith(".tgs"): png_file = os.path.join(DOWN_PATH, f"{rand_key()}.png") cmd = ( f"lottie_convert.py --frame 0 -if lottie " + f"-of png {dls_loc} {png_file}" ) stdout, stderr = (await runcmd(cmd))[:2] os.remove(dls_loc) if not os.path.lexists(png_file): await x.edit_text("This sticker is Gey, Task Failed Successfully ≧ω≦") await asyncio.sleep(5) await x.delete() raise Exception(stdout + stderr) dls_loc = png_file elif replied.sticker and replied.sticker.file_name.endswith(".webp"): stkr_file = os.path.join(DOWN_PATH, f"{rand_key()}.png") os.rename(dls_loc, stkr_file) if not os.path.lexists(stkr_file): await x.edit_text("```Sticker not found...```") await asyncio.sleep(5) await x.delete() return dls_loc = stkr_file elif replied.animation or replied.video: await x.edit_text("`Converting Media To Image ...`") jpg_file = os.path.join(DOWN_PATH, f"{rand_key()}.jpg") await take_screen_shot(dls_loc, 0, jpg_file) os.remove(dls_loc) if not os.path.lexists(jpg_file): await x.edit_text("This Gif is Gey (｡ì _ í｡), Task Failed Successfully !") await asyncio.sleep(5) await x.delete() return dls_loc = jpg_file return dls_loc async def runcmd(cmd: str) -> Tuple[str, str, int, int]: """run command in terminal""" args = shlex.split(cmd) process = await asyncio.create_subprocess_exec( *args, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE ) stdout, stderr = await process.communicate() return ( stdout.decode("utf-8", "replace").strip(), stderr.decode("utf-8", "replace").strip(), process.returncode, process.pid, ) async def take_screen_shot( video_file: str, duration: int, path: str = "" ) -> Optional[str]: """take a screenshot""" print( "[[[Extracting a frame from %s ||| Video duration => %s]]]", video_file, duration, ) thumb_image_path = path or os.path.join(DOWN_PATH, f"{basename(video_file)}.jpg") command = ( f"ffmpeg -ss {duration} " + f'-i "{video_file}" -vframes 1 "{thumb_image_path}"' ) err = (await runcmd(command))[1] if err: print(err) return thumb_image_path if os.path.exists(thumb_image_path) else None async def get_user_from_channel(cid): try: k = (await CC.find_one({"_id": str(cid)}))["usr"] return k except TypeError: return None async def return_json_senpai( query: str, vars_: dict, auth: bool = False, user: int = None ): url = "https://graphql.anilist.co" headers = None if auth: headers = { "Authorization": ( "Bearer " + str((await AUTH_USERS.find_one({"id": int(user)}))["token"]) ), "Content-Type": "application/json", "Accept": "application/json", } return requests.post( url, json={"query": query, "variables": vars_}, headers=headers ).json() def cflag(country): if country == "JP": return "\U0001F1EF\U0001F1F5" if country == "CN": return "\U0001F1E8\U0001F1F3" if country == "KR": return "\U0001F1F0\U0001F1F7" if country == "TW": return "\U0001F1F9\U0001F1FC" def pos_no(no): ep_ = list(str(no)) x = ep_.pop() if ep_ != [] and ep_.pop() == "1": return "th" th = "st" if x == "1" else "nd" if x == "2" else "rd" if x == "3" else "th" return th def make_it_rw(time_stamp): """Converting Time Stamp to Readable Format""" seconds, milliseconds = divmod(int(time_stamp), 1000) minutes, seconds = divmod(seconds, 60) hours, minutes = divmod(minutes, 60) days, hours = divmod(hours, 24) tmp = ( ((str(days) + " Days, ") if days else "") + ((str(hours) + " Hours, ") if hours else "") + ((str(minutes) + " Minutes, ") if minutes else "") + ((str(seconds) + " Seconds, ") if seconds else "") + ((str(milliseconds) + " ms, ") if milliseconds else "") ) return tmp[:-2] async def clog( name: str, text: str, tag: str, msg: Message = None, cq: CallbackQuery = None, replied: Message = None, file: str = None, send_as_file: str = None, ): log = f"#{name.upper()} #{tag.upper()}\n\n{text}" data = "" if msg: data += str(msg) data += "\n\n\n\n" if cq: data += str(cq) data += "\n\n\n\n" await app.send_message(chat_id=MESSAGE_DUMP, text=log) if msg or cq: with open("query_data.txt", "x") as output: output.write(data) await app.send_document(MESSAGE_DUMP, "query_data.txt") os.remove("query_data.txt") if replied: media = replied.photo or replied.sticker or replied.animation or replied.video media_path = await app.download_media(media) await app.send_document(MESSAGE_DUMP, media_path) if file: await app.send_document(MESSAGE_DUMP, file) if send_as_file: with open("dataInQuestio.txt", "x") as text_file: text_file.write() await app.send_document(MESSAGE_DUMP, "dataInQuestio.txt") os.remove("dataInQuestio.txt") def get_btns( media, user: int, result: list, lsqry: str = None, lspage: int = None, auth: bool = False, sfw: str = "False", ): buttons = [] qry = f"_{lsqry}" if lsqry is not None else "" pg = f"_{lspage}" if lspage is not None else "" if media == "ANIME" and sfw == "False": buttons.append( [ InlineKeyboardButton( text="Characters", callback_data=( f"char_{result[2][0]}_ANI" + f"{qry}{pg}_{str(auth)}_1_{user}" ), ), InlineKeyboardButton( text="Description", callback_data=( f"desc_{result[2][0]}_ANI" + f"{qry}{pg}_{str(auth)}_{user}" ), ), InlineKeyboardButton( text="List Series", callback_data=( f"ls_{result[2][0]}_ANI" + f"{qry}{pg}_{str(auth)}_{user}" ), ), ] ) if media == "CHARACTER": buttons.append( [ InlineKeyboardButton( "Description", callback_data=( f"desc_{result[2][0]}_CHAR" + f"{qry}{pg}_{str(auth)}_{user}" ), ) ] ) buttons.append( [ InlineKeyboardButton( "List Series", callback_data=f"lsc_{result[2][0]}{qry}{pg}_{str(auth)}_{user}", ) ] ) if media == "SCHEDULED": if result[0] != 0 and result[0] != 6: buttons.append( [ InlineKeyboardButton( str(day_(result[0] - 1)), callback_data=f"sched_{result[0]-1}_{user}", ), InlineKeyboardButton( str(day_(result[0] + 1)), callback_data=f"sched_{result[0]+1}_{user}", ), ] ) if result[0] == 0: buttons.append( [ InlineKeyboardButton( str(day_(result[0] + 1)), callback_data=f"sched_{result[0]+1}_{user}", ) ] ) if result[0] == 6: buttons.append( [ InlineKeyboardButton( str(day_(result[0] - 1)), callback_data=f"sched_{result[0]-1}_{user}", ) ] ) if media == "MANGA" and sfw == "False": buttons.append([InlineKeyboardButton("More Info", url=result[1][2])]) if media == "AIRING" and sfw == "False": buttons.append([InlineKeyboardButton("More Info", url=result[1][0])]) if auth is True and media != "SCHEDULED" and sfw == "False": auth_btns = get_auth_btns(media, user, result[2], lspage=lspage, lsqry=lsqry) buttons.append(auth_btns) if len(result) > 3: if result[3] == "None": if result[4] != "None": buttons.append( [ InlineKeyboardButton( text="Sequel", callback_data=f"btn_{result[4]}_{str(auth)}_{user}", ) ] ) else: if result[4] != "None": buttons.append( [ InlineKeyboardButton( text="Prequel", callback_data=f"btn_{result[3]}_{str(auth)}_{user}", ), InlineKeyboardButton( text="Sequel", callback_data=f"btn_{result[4]}_{str(auth)}_{user}", ), ] ) else: buttons.append( [ InlineKeyboardButton( text="Prequel", callback_data=f"btn_{result[3]}_{str(auth)}_{user}", ) ] ) if (lsqry is not None) and (len(result) != 1): if lspage == 1: if result[1][1] is True: buttons.append( [ InlineKeyboardButton( text="Next", callback_data=( f"page_{media}{qry}_{int(lspage)+1}_{str(auth)}_{user}" ), ) ] ) else: pass elif lspage != 1: if result[1][1] is False: buttons.append( [ InlineKeyboardButton( text="Prev", callback_data=( f"page_{media}{qry}_{int(lspage)-1}_{str(auth)}_{user}" ), ) ] ) else: buttons.append( [ InlineKeyboardButton( text="Prev", callback_data=( f"page_{media}{qry}_{int(lspage)-1}_{str(auth)}_{user}" ), ), InlineKeyboardButton( text="Next", callback_data=( f"page_{media}{qry}_{int(lspage)+1}_{str(auth)}_{user}" ), ), ] ) return InlineKeyboardMarkup(buttons) def get_auth_btns(media, user, data, lsqry: str = None, lspage: int = None): btn = [] qry = f"_{lsqry}" if lsqry is not None else "" pg = f"_{lspage}" if lspage is not None else "" if media == "CHARACTER": btn.append( InlineKeyboardButton( text=("Add to Favs" if data[1] is not True else "Remove from Favs"), callback_data=f"fav_{media}_{data[0]}{qry}{pg}_{user}", ) ) else: btn.append( InlineKeyboardButton( text=("Add to Favs" if data[3] is not True else "Remove from Favs"), callback_data=f"fav_{media}_{data[0]}{qry}{pg}_{user}", ) ) btn.append( InlineKeyboardButton( text="Add to List" if data[1] is False else "Update in List", callback_data=( f"lsadd_{media}_{data[0]}{qry}{pg}_{user}" if data[1] is False else f"lsupdt_{media}_{data[0]}_{data[2]}{qry}{pg}_{user}" ), ) ) return btn def day_(x: int): if x == 0: return "Monday" if x == 1: return "Tuesday" if x == 2: return "Wednesday" if x == 3: return "Thursday" if x == 4: return "Friday" if x == 5: return "Saturday" if x == 6: return "Sunday" def season_(future: bool = False): k = datetime.now() m = k.month if future: m = m + 3 y = k.year if m > 12: y = y + 1 if m in [1, 2, 3] or m > 12: return "WINTER", y if m in [4, 5, 6]: return "SPRING", y if m in [7, 8, 9]: return "SUMMER", y if m in [10, 11, 12]: return "FALL", y class google_new_transError(Exception): """Exception that uses context to present a meaningful error message""" def __init__(self, msg=None, **kwargs): self.tts = kwargs.pop("tts", None) self.rsp = kwargs.pop("response", None) if msg: self.msg = msg elif self.tts is not None: self.msg = self.infer_msg(self.tts, self.rsp) else: self.msg = None super(google_new_transError, self).__init__(self.msg) def infer_msg(self, tts, rsp=None): cause = "Unknown" if rsp is None: premise = "Failed to connect" return "{}. Probable cause: {}".format(premise, "timeout") # if tts.tld != 'com': # host = _translate_url(tld=tts.tld) # cause = "Host '{}' is not reachable".format(host) else: status = rsp.status_code reason = rsp.reason premise = "{:d} ({}) from TTS API".format(status, reason) if status == 403: cause = "Bad token or upstream API changes" elif status == 200 and not tts.lang_check: cause = ( "No audio stream in response. Unsupported language '%s'" % self.tts.lang ) elif status >= 500: cause = "Uptream API error. Try again later." return "{}. Probable cause: {}".format(premise, cause) class google_translator: """ You can use 108 language in target and source,details view LANGUAGES. Target language: like 'en'、'zh'、'th'... :param url_suffix: The source text(s) to be translated. Batch translation is supported via sequence input. The value should be one of the url_suffix listed in : `DEFAULT_SERVICE_URLS` :type url_suffix: UTF-8 :class:`str`; :class:`unicode`; string sequence (list, tuple, iterator, generator) :param text: The source text(s) to be translated. :type text: UTF-8 :class:`str`; :class:`unicode`; :param lang_tgt: The language to translate the source text into. The value should be one of the language codes listed in : `LANGUAGES` :type lang_tgt: :class:`str`; :class:`unicode` :param lang_src: The language of the source text. The value should be one of the language codes listed in :const:`googletrans.LANGUAGES` If a language is not specified, the system will attempt to identify the source language automatically. :type lang_src: :class:`str`; :class:`unicode` :param timeout: Timeout Will be used for every request. :type timeout: number or a double of numbers :param proxies: proxies Will be used for every request. :type proxies: class : dict; like: {'http': 'http:171.112.169.47:19934/', 'https': 'https:171.112.169.47:19934/'} """ def __init__(self, url_suffix="cn", timeout=5, proxies=None): self.proxies = proxies if url_suffix not in URLS_SUFFIX: self.url_suffix = URL_SUFFIX_DEFAULT else: self.url_suffix = url_suffix url_base = "https://translate.google.{}".format(self.url_suffix) self.url = url_base + "/_/TranslateWebserverUi/data/batchexecute" self.timeout = timeout def _package_rpc(self, text, lang_src="auto", lang_tgt="auto"): GOOGLE_TTS_RPC = ["MkEWBc"] parameter = [[text.strip(), lang_src, lang_tgt, True], [1]] escaped_parameter = json.dumps(parameter, separators=(",", ":")) rpc = [[[random.choice(GOOGLE_TTS_RPC), escaped_parameter, None, "generic"]]] espaced_rpc = json.dumps(rpc, separators=(",", ":")) # text_urldecode = quote(text.strip()) freq_initial = "f.req={}&".format(quote(espaced_rpc)) freq = freq_initial return freq def translate(self, text, lang_tgt="auto", lang_src="auto", pronounce=False): try: lang = LANGUAGES[lang_src] except Exception: lang_src = "auto" try: lang = LANGUAGES[lang_tgt] except Exception: lang_src = "auto" text = str(text) if len(text) >= 5000: return "Warning: Can only detect less than 5000 characters" if len(text) == 0: return "" headers = { "Referer": "http://translate.google.{}/".format(self.url_suffix), "User-Agent": "Mozilla/5.0 (Windows NT 10.0; WOW64) " "AppleWebKit/537.36 (KHTML, like Gecko) " "Chrome/47.0.2526.106 Safari/537.36", "Content-Type": "application/x-www-form-urlencoded;charset=utf-8", } freq = self._package_rpc(text, lang_src, lang_tgt) response = requests.Request( method="POST", url=self.url, data=freq, headers=headers, ) try: if self.proxies is None or type(self.proxies) != dict: self.proxies = {} with requests.Session() as s: s.proxies = self.proxies r = s.send( request=response.prepare(), verify=False, timeout=self.timeout ) for line in r.iter_lines(chunk_size=1024): decoded_line = line.decode("utf-8") if "MkEWBc" in decoded_line: try: response = decoded_line response = json.loads(response) response = list(response) response = json.loads(response[0][2]) response_ = list(response) response = response_[1][0] if len(response) == 1: if len(response[0]) > 5: sentences = response[0][5] else: ## only url sentences = response[0][0] if pronounce is False: return sentences elif pronounce == True: return [sentences, None, None] translate_text = "" for sentence in sentences: sentence = sentence[0] translate_text += sentence.strip() + " " translate_text = translate_text if pronounce is False: return translate_text elif pronounce == True: pronounce_src = response_[0][0] pronounce_tgt = response_[1][0][0][1] return [translate_text, pronounce_src, pronounce_tgt] elif len(response) == 2: sentences = [] for i in response: sentences.append(i[0]) if pronounce is False: return sentences elif pronounce == True: pronounce_src = response_[0][0] pronounce_tgt = response_[1][0][0][1] return [sentences, pronounce_src, pronounce_tgt] except Exception as e: raise e r.raise_for_status() except requests.exceptions.ConnectTimeout as e: raise e except requests.exceptions.HTTPError as e: # Request successful, bad response raise google_new_transError(tts=self, response=r) except requests.exceptions.RequestException as e: # Request failed raise google_new_transError(tts=self) def detect(self, text): text = str(text) if len(text) >= 5000: return log.debug("Warning: Can only detect less than 5000 characters") if len(text) == 0: return "" headers = { "Referer": "http://translate.google.{}/".format(self.url_suffix), "User-Agent": "Mozilla/5.0 (Windows NT 10.0; WOW64) " "AppleWebKit/537.36 (KHTML, like Gecko) " "Chrome/47.0.2526.106 Safari/537.36", "Content-Type": "application/x-www-form-urlencoded;charset=utf-8", } freq = self._package_rpc(text) response = requests.Request( method="POST", url=self.url, data=freq, headers=headers ) try: if self.proxies is None or type(self.proxies) != dict: self.proxies = {} with requests.Session() as s: s.proxies = self.proxies r = s.send( request=response.prepare(), verify=False, timeout=self.timeout ) for line in r.iter_lines(chunk_size=1024): decoded_line = line.decode("utf-8") if "MkEWBc" in decoded_line: # regex_str = r"\[\[\"wrb.fr\",\"MkEWBc\",\"\[\[(.*).*?,\[\[\[" try: # data_got = re.search(regex_str,decoded_line).group(1) response = decoded_line response = json.loads(response) response = list(response) response = json.loads(response[0][2]) response = list(response) detect_lang = response[0][2] except Exception: raise Exception # data_got = data_got.split('\\\"]')[0] return [detect_lang, LANGUAGES[detect_lang.lower()]] r.raise_for_status() except requests.exceptions.HTTPError as e: # Request successful, bad response log.debug(str(e)) raise google_new_transError(tts=self, response=r) except requests.exceptions.RequestException as e: # Request failed log.debug(str(e)) raise google_new_transError(tts=self) async def uidata(id_): data = await GUI.find_one({"_id": str(id_)}) if data is not None: bullet = str(data["bl"]) + " " if data["bl"] is None: bullet = "" return bullet, data["cs"] return ["➤ ", "UPPER"] async def get_ui_text(case): if case == "UPPER": return [ "SOURCE", "TYPE", "SCORE", "DURATION", "USER DATA", "ADULT RATED", "STATUS", "GENRES", "TAGS", "SEQUEL", "PREQUEL", "NEXT AIRING", "DESCRIPTION", "VOLUMES", "CHAPTERS", ] else: return [ "Source", "Type", "Score", "Duration", "User Data", "Adult Rated", "Status", "Genres", "Tags", "Sequel", "Prequel", "Next Airing", "Description", "Volumes", "Chapters", ] tr = google_translator() ANIME_DB, MANGA_DB, CHAR_DB, STUDIO_DB, AIRING_DB = {}, {}, {}, {}, {} GUI = get_collection("GROUP_UI") #### Anilist part #### ANIME_TEMPLATE = """{name} **ID | MAL ID:** `{idm}` | `{idmal}` {bl}**{psrc}:** `{source}` {bl}**{ptype}:** `{formats}`{avscd}{dura}{user_data} {status_air}{gnrs_}{tags_} 🎬 {trailer_link} 📖 Official Site {additional}""" # GraphQL Queries. ANIME_QUERY = """ query ($id: Int, $idMal:Int, $search: String) { Media (id: $id, idMal: $idMal, search: $search, type: ANIME) { id idMal title { romaji english native } format status episodes duration countryOfOrigin source (version: 2) trailer { id site } genres tags { name } averageScore relations { edges { node { title { romaji english } id type } relationType } } nextAiringEpisode { timeUntilAiring episode } isAdult isFavourite mediaListEntry { status score id } siteUrl } } """ ISADULT = """ query ($id: Int) { Media (id: $id) { isAdult } } """ BROWSE_QUERY = """ query ($s: MediaSeason, $y: Int, $sort: [MediaSort]) { Page { media (season: $s, seasonYear: $y, sort: $sort) { title { romaji } format } } } """ FAV_ANI_QUERY = """ query ($id: Int, $page: Int) { User (id: $id) { favourites { anime (page: $page, perPage: 10) { pageInfo { lastPage hasNextPage } edges { node { title { romaji } siteUrl } } } } } } """ FAV_MANGA_QUERY = """ query ($id: Int, $page: Int) { User (id: $id) { favourites { manga (page: $page, perPage: 10) { pageInfo { lastPage hasNextPage } edges { node { title { romaji } siteUrl } } } } } } """ FAV_CHAR_QUERY = """ query ($id: Int, $page: Int) { User (id: $id) { favourites { characters (page: $page, perPage: 10) { pageInfo { lastPage hasNextPage } edges { node { name { full } siteUrl } } } } } } """ VIEWER_QRY = """ query { Viewer { id name siteUrl statistics { anime { count minutesWatched episodesWatched meanScore } manga { count chaptersRead volumesRead meanScore } } } } """ USER_QRY = """ query ($search: String) { User (name: $search) { id name siteUrl statistics { anime { count minutesWatched episodesWatched meanScore } manga { count chaptersRead volumesRead meanScore } } } } """ ANIME_MUTATION = """ mutation ($id: Int) { ToggleFavourite (animeId: $id) { anime { pageInfo { total } } } } """ MANGA_MUTATION = """ mutation ($id: Int) { ToggleFavourite (mangaId: $id) { manga { pageInfo { total } } } } """ STUDIO_MUTATION = """ mutation ($id: Int) { ToggleFavourite (studioId: $id) { studios { pageInfo { total } } } } """ CHAR_MUTATION = """ mutation ($id: Int) { ToggleFavourite (characterId: $id) { characters { pageInfo { total } } } } """ ANILIST_MUTATION = """ mutation ($id: Int, $status: MediaListStatus) { SaveMediaListEntry (mediaId: $id, status: $status) { media { title { romaji } } } } """ ANILIST_MUTATION_UP = """ mutation ($id: [Int], $status: MediaListStatus) { UpdateMediaListEntries (ids: $id, status: $status) { media { title { romaji } } } } """ ANILIST_MUTATION_DEL = """ mutation ($id: Int) { DeleteMediaListEntry (id: $id) { deleted } } """ AIR_QUERY = """ query ($search: String, $page: Int) { Page (perPage: 1, page: $page) { pageInfo { total hasNextPage } media (search: $search, type: ANIME) { id title { romaji english } status countryOfOrigin nextAiringEpisode { timeUntilAiring episode } siteUrl isFavourite isAdult mediaListEntry { status id } } } } """ DES_INFO_QUERY = """ query ($id: Int) { Media (id: $id) { id description (asHtml: false) } } """ CHA_INFO_QUERY = """ query ($id: Int, $page: Int) { Media (id: $id, type: ANIME) { id characters (page: $page, perPage: 25, sort: ROLE) { pageInfo { hasNextPage lastPage total } edges { node { name { full } } role } } } } """ REL_INFO_QUERY = """ query ($id: Int) { Media (id: $id, type: ANIME) { id relations { edges { node { title { romaji } type } relationType } } } } """ PAGE_QUERY = """ query ($search: String, $page: Int) { Page (perPage: 1, page: $page) { pageInfo { total hasNextPage } media (search: $search, type: ANIME) { id idMal title { romaji english native } format status episodes duration countryOfOrigin source (version: 2) trailer { id site } genres tags { name } averageScore relations { edges { node { title { romaji english } type } relationType } } nextAiringEpisode { timeUntilAiring episode } isAdult isFavourite mediaListEntry { status score id } siteUrl } } } """ CHARACTER_QUERY = """ query ($id: Int, $search: String, $page: Int) { Page (perPage: 1, page: $page) { pageInfo { total hasNextPage } characters (id: $id, search: $search) { id name { full native } image { large } media (type: ANIME) { edges { node { title { romaji } type } voiceActors (language: JAPANESE) { name { full } siteUrl } } } isFavourite siteUrl } } } """ MANGA_QUERY = """ query ($search: String, $page: Int) { Page (perPage: 1, page: $page) { pageInfo { total hasNextPage } media (search: $search, type: MANGA) { id title { romaji english native } format countryOfOrigin source (version: 2) status description(asHtml: true) chapters isFavourite mediaListEntry { status score id } volumes averageScore siteUrl isAdult } } } """ DESC_INFO_QUERY = """ query ($id: Int) { Character (id: $id) { image { large } description(asHtml: false) } } """ LS_INFO_QUERY = """ query ($id: Int) { Character (id: $id) { image { large } media (page: 1, perPage: 25) { nodes { title { romaji english } type } } } } """ ACTIVITY_QUERY = """ query ($id: Int) { Page (perPage: 12) { activities (userId: $id, type: MEDIA_LIST, sort: ID_DESC) { ...kek } } } fragment kek on ListActivity { type media { title { romaji } siteUrl } progress status } """ TOP_QUERY = """ query ($gnr: String, $page: Int) { Page (perPage: 15, page: $page) { pageInfo { lastPage total hasNextPage } media (genre: $gnr, sort: SCORE_DESC, type: ANIME) { title { romaji } } } } """ TOPT_QUERY = """ query ($gnr: String, $page: Int) { Page (perPage: 15, page: $page) { pageInfo { lastPage total hasNextPage } media (tag: $gnr, sort: SCORE_DESC, type: ANIME) { title { romaji } } } } """ ALLTOP_QUERY = """ query ($page: Int) { Page (perPage: 15, page: $page) { pageInfo { lastPage total hasNextPage } media (sort: SCORE_DESC, type: ANIME) { title { romaji } } } } """ GET_GENRES = """ query { GenreCollection } """ GET_TAGS = """ query{ MediaTagCollection { name isAdult } } """ RECOMMENDTIONS_QUERY = """ query ($id: Int) { Media (id: $id) { recommendations (perPage: 25) { edges { node { mediaRecommendation { title { romaji } id siteUrl } } } } } } """ STUDIO_QUERY = """ query ($search: String, $page: Int) { Page (page: $page, perPage: 1) { pageInfo { total hasNextPage } studios (search: $search) { id name siteUrl isFavourite } } } """ STUDIO_ANI_QUERY = """ query ($id: Int, $page: Int) { Studio (id: $id) { name media (page: $page) { pageInfo { total lastPage hasNextPage } edges { node { title { romaji } seasonYear } } } } } """ async def get_studios(qry, page, user, duser=None, auth: bool = False): page = int(page) vars_ = {"search": STUDIO_DB[qry], "page": int(page)} result = await return_json_senpai(STUDIO_QUERY, vars_, auth, user) if result["data"]["Page"]["studios"] == []: return ["Not Found"] data = result["data"]["Page"]["studios"][0] isFav = data["isFavourite"] msg = ( f"**{data['name']}**{', ♥️' if isFav is True else ''}" + f"\n\n**ID:** {data['id']}\n[Website]({data['siteUrl']})" ) if not duser: duser = user btns = [] btns.append( [ InlineKeyboardButton( "List Animes", callback_data=f"stuani_1_{data['id']}_{page}_{qry}_{auth}_{duser}", ) ] ) if auth: btns.append( [ InlineKeyboardButton( "Remove from Favs" if isFav else "Add To Favs", callback_data=f"fav_STUDIO_{data['id']}_{qry}_{page}_{duser}", ) ] ) pi = result["data"]["Page"]["pageInfo"]["hasNextPage"] if pi is False: if int(page) == 1: return msg, btns else: btns.append( [ InlineKeyboardButton( "Prev", callback_data=f"pgstudio_{page-1}_{qry}_{auth}_{duser}" ) ] ) else: if int(page) == 1: btns.append( [ InlineKeyboardButton( "Next", callback_data=f"pgstudio_2_{qry}_{auth}_{duser}" ) ] ) else: btns.append( [ InlineKeyboardButton( "Prev", callback_data=f"pgstudio_{page-1}_{qry}_{auth}_{duser}" ), InlineKeyboardButton( "Next", callback_data=f"pgstudio_{page+1}_{qry}_{auth}_{duser}" ), ] ) return msg, InlineKeyboardMarkup(btns) async def get_studio_animes(id_, page, qry, rp, user, duser=None, auth: bool = False): vars_ = {"id": id_, "page": int(page)} result = await return_json_senpai(STUDIO_ANI_QUERY, vars_, auth, user) data = result["data"]["Studio"]["media"]["edges"] if data == []: return ["No results found"] msg = f"List of animes by {result['data']['Studio']['name']} studio\n" for i in data: msg += ( f"\n⚬ `{i['node']['title']['romaji']}`" + f" __({i['node']['seasonYear']})__" ) btns = [] if not duser: duser = user pi = result["data"]["Studio"]["media"]["pageInfo"] if pi["hasNextPage"] is False: if int(page) == 1: btns.append( [ InlineKeyboardButton( "Back", callback_data=f"pgstudio_{rp}_{qry}_{auth}_{duser}" ) ] ) return msg, btns else: btns.append( [ InlineKeyboardButton( "Prev", callback_data=f"stuani_{int(page)-1}_{id_}_{rp}_{qry}_{auth}_{duser}", ) ] ) else: if int(page) == 1: btns.append( [ InlineKeyboardButton( "Next", callback_data=f"stuani_2_{id_}_{rp}_{qry}_{auth}_{duser}", ) ] ) else: btns.append( [ InlineKeyboardButton( "Prev", callback_data=f"stuani_{int(page)-1}_{id_}_{rp}_{qry}_{auth}_{duser}", ), InlineKeyboardButton( "Next", callback_data=f"stuani_{int(page)+1}_{id_}_{rp}_{qry}_{auth}_{duser}", ), ] ) btns.append( [ InlineKeyboardButton( "Back", callback_data=f"pgstudio_{rp}_{qry}_{auth}_{duser}" ) ] ) return msg, InlineKeyboardMarkup(btns) async def get_all_tags(text: str = None): vars_ = {} result = await return_json_senpai(GET_TAGS, vars_, auth=False, user=None) msg = "**Tags List:**\n\n`" kek = [] for i in result["data"]["MediaTagCollection"]: if text is not None and "nsfw" in text: if str(i["isAdult"]) != "False": kek.append(i["name"]) else: if str(i["isAdult"]) == "False": kek.append(i["name"]) msg += ", ".join(kek) msg += "`" return msg async def get_all_genres(): vars_ = {} result = await return_json_senpai(GET_GENRES, vars_, auth=False) msg = "**Genres List:**\n\n" for i in result["data"]["GenreCollection"]: msg += f"`{i}`\n" return msg async def get_user_activity(id_, user, duser=None): vars_ = {"id": id_} result = await return_json_senpai(ACTIVITY_QUERY, vars_, auth=True, user=user) data = result["data"]["Page"]["activities"] msg = "" for i in data: try: name = f"[{i['media']['title']['romaji']}]" + f"({i['media']['siteUrl']})" if i["status"] in ["watched episode", "read chapter"]: msg += ( f"⚬ {str(i['status']).capitalize()} " + f"{i['progress']} of {name}\n" ) else: progress = i["progress"] of = "of" if i["status"] == "dropped": of = "at" msg += ( f"⚬ {str(i['status']).capitalize()}" + f"{f'{progress} {of} ' if progress is not None else ' '}" + f"{name}\n" ) except KeyError: pass if duser is None: duser = user btn = [[InlineKeyboardButton("Back", callback_data=f"getusrbc_{duser}")]] return [ f"https://img.anili.st/user/{id_}?a={time.time()}", msg, InlineKeyboardMarkup(btn), ] async def get_recommendations(id_): vars_ = {"id": int(id_)} result = await return_json_senpai(RECOMMENDTIONS_QUERY, vars_) data = result["data"]["Media"]["recommendations"]["edges"] rc_ls = [] for i in data: ii = i["node"]["mediaRecommendation"] rc_ls.append([ii["title"]["romaji"], ii["id"], ii["siteUrl"]]) if rc_ls == []: return "No Recommendations available related to given anime!!!" outstr = "Recommended animes:\n\n" for i in rc_ls: outstr += ( f"**{i[0]}**\n ➥[Synopsis]" + f"(https://t.me/{BOT_USERNAME}?astart=anime_{i[1]})" + f"\n ➥[Official Site]({i[2]})\n\n" ) return outstr async def get_top_animes(gnr: str, page, user): vars_ = {"gnr": gnr.lower(), "page": int(page)} query = TOP_QUERY msg = f"Top animes for genre `{gnr.capitalize()}`:\n\n" if gnr == "None": query = ALLTOP_QUERY vars_ = {"page": int(page)} msg = f"Top animes:\n\n" nsfw = False result = await return_json_senpai(query, vars_, auth=False, user=user) if len(result["data"]["Page"]["media"]) == 0: query = TOPT_QUERY msg = f"Top animes for tag `{gnr.capitalize()}`:\n\n" result = await return_json_senpai(query, vars_, auth=False, user=user) if len(result["data"]["Page"]["media"]) == 0: return [f"No results Found"] nsls = await get_all_tags("nsfw") nsfw = True if gnr.lower() in nsls.lower() else False data = result["data"]["Page"] for i in data["media"]: msg += f"⚬ `{i['title']['romaji']}`\n" msg += f"\nTotal available animes: `{data['pageInfo']['total']}`" btn = [] if int(page) == 1: if int(data["pageInfo"]["lastPage"]) != 1: btn.append( [ InlineKeyboardButton( "Next", callback_data=f"topanimu_{gnr}_{int(page)+1}_{user}" ) ] ) elif int(page) == int(data["pageInfo"]["lastPage"]): btn.append( [ InlineKeyboardButton( "Prev", callback_data=f"topanimu_{gnr}_{int(page)-1}_{user}" ) ] ) else: btn.append( [ InlineKeyboardButton( "Prev", callback_data=f"topanimu_{gnr}_{int(page)-1}_{user}" ), InlineKeyboardButton( "Next", callback_data=f"topanimu_{gnr}_{int(page)+1}_{user}" ), ] ) return [msg, nsfw], InlineKeyboardMarkup(btn) if len(btn) != 0 else "" async def get_user_favourites(id_, user, req, page, sighs, duser=None): vars_ = {"id": int(id_), "page": int(page)} result = await return_json_senpai( ( FAV_ANI_QUERY if req == "ANIME" else FAV_CHAR_QUERY if req == "CHAR" else FAV_MANGA_QUERY ), vars_, auth=True, user=int(user), ) data = result["data"]["User"]["favourites"][ "anime" if req == "ANIME" else "characters" if req == "CHAR" else "manga" ] msg = ( "Favourite Animes:\n\n" if req == "ANIME" else "Favourite Characters:\n\n" if req == "CHAR" else "Favourite Manga:\n\n" ) for i in data["edges"]: node_name = ( i["node"]["title"]["romaji"] if req != "CHAR" else i["node"]["name"]["full"] ) msg += f"⚬ [{node_name}]({i['node']['siteUrl']})\n" btn = [] if duser is None: duser = user if int(page) == 1: if int(data["pageInfo"]["lastPage"]) != 1: btn.append( [ InlineKeyboardButton( "Next", callback_data=( f"myfavqry_{req}_{id_}_{str(int(page)+1)}" + f"_{sighs}_{duser}" ), ) ] ) elif int(page) == int(data["pageInfo"]["lastPage"]): btn.append( [ InlineKeyboardButton( "Prev", callback_data=( f"myfavqry_{req}_{id_}_{str(int(page)-1)}_{sighs}_{duser}" ), ) ] ) else: btn.append( [ InlineKeyboardButton( "Prev", callback_data=( f"myfavqry_{req}_{id_}_{str(int(page)-1)}_{sighs}_{duser}" ), ), InlineKeyboardButton( "Next", callback_data=( f"myfavqry_{req}_{id_}_{str(int(page)+1)}_{sighs}_{duser}" ), ), ] ) btn.append( [InlineKeyboardButton("Back", callback_data=f"myfavs_{id_}_{sighs}_{user}")] ) return [ f"https://img.anili.st/user/{id_}?a=({time.time()})", msg, InlineKeyboardMarkup(btn), ] async def get_featured_in_lists( idm, req, auth: bool = False, user: int = None, page: int = 0 ): vars_ = {"id": int(idm)} result = await return_json_senpai(LS_INFO_QUERY, vars_, auth=auth, user=user) data = result["data"]["Character"]["media"]["nodes"] if req == "ANI": out = "ANIMES:\n\n" out_ = [] for ani in data: k = ani["title"]["english"] or ani["title"]["romaji"] kk = ani["type"] if kk == "ANIME": out_.append(f"• __{k}__\n") else: out = "MANGAS:\n\n" out_ = [] for ani in data: k = ani["title"]["english"] or ani["title"]["romaji"] kk = ani["type"] if kk == "MANGA": out_.append(f"• __{k}__\n") total = len(out_) for _ in range(15 * page): out_.pop(0) out_ = "".join(out_[:15]) return ([out + out_, total] if len(out_) != 0 else False), result["data"][ "Character" ]["image"]["large"] async def get_additional_info( idm, ctgry, req=None, auth: bool = False, user: int = None, page: int = 0 ): vars_ = {"id": int(idm)} if req == "char": vars_["page"] = page result = await return_json_senpai( ( ( DES_INFO_QUERY if req == "desc" else CHA_INFO_QUERY if req == "char" else REL_INFO_QUERY ) if ctgry == "ANI" else DESC_INFO_QUERY ), vars_, ) data = result["data"]["Media"] if ctgry == "ANI" else result["data"]["Character"] pic = f"https://img.anili.st/media/{idm}" if req == "desc": synopsis = data.get("description") if os.environ.get("PREFERRED_LANGUAGE"): synopsis = tr.translate( synopsis, lang_tgt=os.environ.get("PREFERRED_LANGUAGE") ) return (pic if ctgry == "ANI" else data["image"]["large"]), synopsis elif req == "char": charlist = [] for char in data["characters"]["edges"]: charlist.append(f"• `{char['node']['name']['full']}` ({char['role']})") chrctrs = ("\n").join(charlist) charls = f"{chrctrs}" if len(charlist) != 0 else "" return pic, charls, data["characters"]["pageInfo"] else: prqlsql = data.get("relations").get("edges") ps = "" for i in prqlsql: ps += ( f'• {i["node"]["title"]["romaji"]} ' + f'({i["node"]["type"]}) `{i["relationType"]}`\n' ) return pic, ps async def get_anime(vars_, auth: bool = False, user: int = None, cid: int = None): result = await return_json_senpai(ANIME_QUERY, vars_, auth=auth, user=user) error = result.get("errors") if error: error_sts = error[0].get("message") return [f"[{error_sts}]"] data = result["data"]["Media"] # Data of all fields in returned json # pylint: disable=possibly-unused-variable idm = data.get("id") idmal = data.get("idMal") romaji = data["title"]["romaji"] english = data["title"]["english"] native = data["title"]["native"] formats = data.get("format") status = data.get("status") episodes = data.get("episodes") duration = data.get("duration") country = data.get("countryOfOrigin") c_flag = cflag(country) source = data.get("source") prqlsql = data.get("relations").get("edges") adult = data.get("isAdult") url = data.get("siteUrl") trailer_link = "N/A" gnrs = ", ".join(data["genres"]) score = data["averageScore"] bl, cs = await uidata(cid) text = await get_ui_text(cs) psrc, ptype = text[0], text[1] avscd = f"\n{bl}**{text[2]}:** `{score}%` 🌟" if score is not None else "" tags = [] for i in data["tags"]: tags.append(i["name"]) tags_ = f"\n{bl}**{text[8]}:** `{', '.join(tags[:5])}`" if tags != [] else "" bot = BOT_USERNAME.replace("@", "") gnrs_ = "" if len(gnrs) != 0: gnrs_ = f"\n{bl}**{text[7]}:** `{gnrs}`" isfav = data.get("isFavourite") fav = ", in Favourites" if isfav is True else "" user_data = "" in_ls = False in_ls_id = "" if auth is True: in_list = data.get("mediaListEntry") if in_list is not None: in_ls = True in_ls_id = in_list["id"] in_ls_stts = in_list["status"] in_ls_score = ( f" and scored {in_list['score']}" if in_list["score"] != 0 else "" ) user_data = f"\n{bl}**{text[4]}:** `{in_ls_stts}{fav}{in_ls_score}`" if data["title"]["english"] is not None: name = f"""[{c_flag}]**{romaji}** | {native}""" else: name = f"""[{c_flag}]**{romaji}** | {native}""" prql, prql_id, sql, sql_id = "", "None", "", "None" for i in prqlsql: if i["relationType"] == "PREQUEL" and i["node"]["type"] == "ANIME": pname = ( i["node"]["title"]["english"] if i["node"]["title"]["english"] is not None else i["node"]["title"]["romaji"] ) prql += f"**{text[10]}:** `{pname}`\n" prql_id = i["node"]["id"] break for i in prqlsql: if i["relationType"] == "SEQUEL" and i["node"]["type"] == "ANIME": sname = ( i["node"]["title"]["english"] if i["node"]["title"]["english"] is not None else i["node"]["title"]["romaji"] ) sql += f"**{text[9]}:** `{sname}`\n" sql_id = i["node"]["id"] break additional = f"{prql}{sql}" surl = f"https://t.me/{bot}/?astart=des_ANI_{idm}_desc" dura = f"\n{bl}**{text[3]}:** `{duration} min/ep`" if duration is not None else "" air_on = None if data["nextAiringEpisode"]: nextAir = data["nextAiringEpisode"]["timeUntilAiring"] air_on = make_it_rw(nextAir * 1000) eps = data["nextAiringEpisode"]["episode"] th = pos_no(str(eps)) air_on += f" | {eps}{th} eps" if air_on is None: eps_ = f"` | `{episodes} eps" if episodes is not None else "" status_air = f"{bl}**{text[6]}:** `{status}{eps_}`" else: status_air = f"{bl}**{text[6]}:** `{status}`\n{bl}**{text[11]}:** `{air_on}`" if data["trailer"] and data["trailer"]["site"] == "youtube": trailer_link = f"Trailer" title_img = f"https://img.anili.st/media/{idm}" try: finals_ = ANIME_TEMPLATE.format(**locals()) except KeyError as kys: return [f"{kys}"] return ( title_img, finals_, [idm, in_ls, in_ls_id, isfav, str(adult)], prql_id, sql_id, ) async def get_anilist(qdb, page, auth: bool = False, user: int = None, cid: int = None): vars_ = {"search": ANIME_DB[qdb], "page": page} result = await return_json_senpai(PAGE_QUERY, vars_, auth=auth, user=user) if len(result["data"]["Page"]["media"]) == 0: return [f"No results Found"] data = result["data"]["Page"]["media"][0] # Data of all fields in returned json # pylint: disable=possibly-unused-variable idm = data.get("id") bot = BOT_USERNAME.replace("@", "") idmal = data.get("idMal") romaji = data["title"]["romaji"] english = data["title"]["english"] native = data["title"]["native"] formats = data.get("format") status = data.get("status") episodes = data.get("episodes") duration = data.get("duration") country = data.get("countryOfOrigin") c_flag = cflag(country) source = data.get("source") prqlsql = data.get("relations").get("edges") adult = data.get("isAdult") trailer_link = "N/A" isfav = data.get("isFavourite") gnrs = ", ".join(data["genres"]) gnrs_ = "" bl, cs = await uidata(cid) text = await get_ui_text(cs) psrc, ptype = text[0], text[1] if len(gnrs) != 0: gnrs_ = f"\n{bl}**{text[7]}:** `{gnrs}`" fav = ", in Favourites" if isfav is True else "" score = data["averageScore"] avscd = f"\n{bl}**{text[2]}:** `{score}%` 🌟" if score is not None else "" tags = [] for i in data["tags"]: tags.append(i["name"]) tags_ = f"\n{bl}**{text[8]}:** `{', '.join(tags[:5])}`" if tags != [] else "" in_ls = False in_ls_id = "" user_data = "" if auth is True: in_list = data.get("mediaListEntry") if in_list is not None: in_ls = True in_ls_id = in_list["id"] in_ls_stts = in_list["status"] in_ls_score = ( f" and scored {in_list['score']}" if in_list["score"] != 0 else "" ) user_data = f"\n{bl}**{text[4]}:** `{in_ls_stts}{fav}{in_ls_score}`" if data["title"]["english"] is not None: name = f"[{c_flag}]**{english}** (`{native}`)" else: name = f"[{c_flag}]**{romaji}** (`{native}`)" prql, sql = "", "" for i in prqlsql: if i["relationType"] == "PREQUEL" and i["node"]["type"] == "ANIME": pname = ( i["node"]["title"]["english"] if i["node"]["title"]["english"] is not None else i["node"]["title"]["romaji"] ) prql += f"**{text[10]}:** `{pname}`\n" break for i in prqlsql: if i["relationType"] == "SEQUEL" and i["node"]["type"] == "ANIME": sname = ( i["node"]["title"]["english"] if i["node"]["title"]["english"] is not None else i["node"]["title"]["romaji"] ) sql += f"**{text[9]}:** `{sname}`\n" break additional = f"{prql}{sql}" additional.replace("-", "") dura = f"\n{bl}**{text[3]}:** `{duration} min/ep`" if duration is not None else "" air_on = None if data["nextAiringEpisode"]: nextAir = data["nextAiringEpisode"]["timeUntilAiring"] air_on = make_it_rw(nextAir * 1000) eps = data["nextAiringEpisode"]["episode"] th = pos_no(str(eps)) air_on += f" | {eps}{th} eps" if air_on is None: eps_ = f"` | `{episodes} eps" if episodes is not None else "" status_air = f"{bl}**{text[6]}:** `{status}{eps_}`" else: status_air = f"{bl}**{text[6]}:** `{status}`\n{bl}**{text[11]}:** `{air_on}`" if data["trailer"] and data["trailer"]["site"] == "youtube": trailer_link = f"Trailer" url = data.get("siteUrl") title_img = f"https://img.anili.st/media/{idm}" surl = f"https://t.me/{bot}/?astart=des_ANI_{idm}_desc" hasNextPage = result["data"]["Page"]["pageInfo"]["hasNextPage"] try: finals_ = ANIME_TEMPLATE.format(**locals()) except KeyError as kys: return [f"{kys}"] return title_img, [finals_, hasNextPage], [idm, in_ls, in_ls_id, isfav, str(adult)] async def get_character(query, page, auth: bool = False, user: int = None): var = {"search": CHAR_DB[query], "page": int(page)} result = await return_json_senpai(CHARACTER_QUERY, var, auth=auth, user=user) if len(result["data"]["Page"]["characters"]) == 0: return [f"No results Found"] data = result["data"]["Page"]["characters"][0] # Character Data id_ = data["id"] name = data["name"]["full"] native = data["name"]["native"] img = data["image"]["large"] site_url = data["siteUrl"] isfav = data.get("isFavourite") va = [] for i in data["media"]["edges"]: for ii in i["voiceActors"]: if f"[{ii['name']['full']}]({ii['siteUrl']})" not in va: va.append(f"[{ii['name']['full']}]({ii['siteUrl']})") lva = None if len(va) > 1: lva = va.pop() sva = ( f"\n**Voice Actors:** {', '.join(va)}" + f"{' and '+lva if lva is not None else ''}\n" if va != [] else "" ) cap_text = f""" __{native}__ (`{name}`) **ID:** {id_} {sva} Visit Website""" hasNextPage = result["data"]["Page"]["pageInfo"]["hasNextPage"] return img, [cap_text, hasNextPage], [id_, isfav] async def browse_(qry: str): s, y = season_() sort = "POPULARITY_DESC" if qry == "upcoming": s, y = season_(True) if qry == "trending": sort = "TRENDING_DESC" vars_ = {"s": s, "y": y, "sort": sort} result = await return_json_senpai(BROWSE_QUERY, vars_) data = result["data"]["Page"]["media"] ls = [] for i in data: if i["format"] in ["TV", "MOVIE", "ONA"]: ls.append("• `" + i["title"]["romaji"] + "`") out = f"{qry.capitalize()} animes in {s} {y}:\n\n" return out + "\n".join(ls[:20]) async def get_manga(qdb, page, auth: bool = False, user: int = None, cid: int = None): vars_ = {"search": MANGA_DB[qdb], "asHtml": True, "page": page} result = await return_json_senpai(MANGA_QUERY, vars_, auth=auth, user=user) if len(result["data"]["Page"]["media"]) == 0: return [f"No results Found"] data = result["data"]["Page"]["media"][0] # Data of all fields in returned json # pylint: disable=possibly-unused-variable idm = data.get("id") romaji = data["title"]["romaji"] english = data["title"]["english"] native = data["title"]["native"] status = data.get("status") synopsis = data.get("description") description = synopsis[:500] description_s = "" if len(synopsis) > 500: description += f"..." description_s = ( f"[Click for more info](https://t.me/{BOT_USERNAME}" + f"/?astart=des_ANI_{idm}_desc)" ) volumes = data.get("volumes") chapters = data.get("chapters") score = data.get("averageScore") url = data.get("siteUrl") format_ = data.get("format") country = data.get("countryOfOrigin") source = data.get("source") c_flag = cflag(country) isfav = data.get("isFavourite") adult = data.get("isAdult") fav = ", in Favourites" if isfav is True else "" in_ls = False in_ls_id = "" bl, cs = await uidata(cid) text = await get_ui_text(cs) user_data = "" if auth is True: in_list = data.get("mediaListEntry") if in_list is not None: in_ls = True in_ls_id = in_list["id"] in_ls_stts = in_list["status"] in_ls_score = ( f" and scored {in_list['score']}" if in_list["score"] != 0 else "" ) user_data = f"{bl}**{text[4]}:** `{in_ls_stts}{fav}{in_ls_score}`\n" name = f"""[{c_flag}]**{romaji}** __{english}__ {native}""" if english is None: name = f"""[{c_flag}]**{romaji}** {native}""" finals_ = f"{name}\n\n" finals_ += f"{bl}**ID:** `{idm}`\n" finals_ += f"{bl}**{text[6]}:** `{status}`\n" finals_ += f"{bl}**{text[13]}:** `{volumes}`\n" finals_ += f"{bl}**{text[14]}:** `{chapters}`\n" finals_ += f"{bl}**{text[2]}:** `{score}`\n" finals_ += f"{bl}**{text[1]}:** `{format_}`\n" finals_ += f"{bl}**{text[0]}:** `{source}`\n" finals_ += user_data if os.environ.get("PREFERRED_LANGUAGE"): description = tr.translate( description, lang_tgt=os.environ.get("PREFERRED_LANGUAGE") ) findesc = "" if description == "" else f"`{description}`" finals_ += f"\n**{text[12]}**: {findesc}\n\n{description_s}" pic = f"https://img.anili.st/media/{idm}" return ( pic, [finals_, result["data"]["Page"]["pageInfo"]["hasNextPage"], url], [idm, in_ls, in_ls_id, isfav, str(adult)], ) async def get_airing(qry, ind: int, auth: bool = False, user: int = None): vars_ = {"search": AIRING_DB[qry], "page": int(ind)} result = await return_json_senpai(AIR_QUERY, vars_, auth=auth, user=user) error = result.get("errors") if error: error_sts = error[0].get("message") return [f"{error_sts}"] try: data = result["data"]["Page"]["media"][0] except IndexError: return ["No results Found"] # Airing Details mid = data.get("id") romaji = data["title"]["romaji"] english = data["title"]["english"] status = data.get("status") country = data.get("countryOfOrigin") c_flag = cflag(country) coverImg = f"https://img.anili.st/media/{mid}" isfav = data.get("isFavourite") adult = data.get("isAdult") in_ls = False in_ls_id = "" user_data = "" if auth is True: in_list = data.get("mediaListEntry") if in_list is not None: in_ls = True in_ls_id = in_list["id"] in_ls_stts = in_list["status"] user_data = f"**USER DATA:** `{in_ls_stts}`\n" air_on = None if data["nextAiringEpisode"]: nextAir = data["nextAiringEpisode"]["timeUntilAiring"] episode = data["nextAiringEpisode"]["episode"] th = pos_no(episode) air_on = make_it_rw(nextAir * 1000) title_ = english or romaji out = f"[{c_flag}] **{title_}**" out += f"\n\n**ID:** `{mid}`" out += f"\n**Status:** `{status}`\n" out += user_data if air_on: out += f"Airing Episode `{episode}{th}` in `{air_on}`" site = data["siteUrl"] return ( [coverImg, out], [site, result["data"]["Page"]["pageInfo"]["hasNextPage"]], [mid, in_ls, in_ls_id, isfav, str(adult)], ) async def toggle_favourites(id_: int, media: str, user: int): vars_ = {"id": int(id_)} query = ( ANIME_MUTATION if media == "ANIME" or media == "AIRING" else ( CHAR_MUTATION if media == "CHARACTER" else MANGA_MUTATION if media == "MANGA" else STUDIO_MUTATION ) ) k = await return_json_senpai(query=query, vars_=vars_, auth=True, user=int(user)) try: kek = k["data"]["ToggleFavourite"] return "ok" except KeyError: return "failed" async def get_user(vars_, req, user, display_user=None): query = USER_QRY if "user" in req else VIEWER_QRY k = await return_json_senpai( query=query, vars_=vars_, auth=False if "user" in req else True, user=int(user) ) error = k.get("errors") if error: error_sts = error[0].get("message") return [f"{error_sts}"] data = k["data"]["User" if "user" in req else "Viewer"] anime = data["statistics"]["anime"] manga = data["statistics"]["manga"] stats = f""" **Anime Stats**: Total Anime Watched: `{anime['count']}` Total Episode Watched: `{anime['episodesWatched']}` Total Time Spent: `{anime['minutesWatched']}` Average Score: `{anime['meanScore']}` **Manga Stats**: Total Manga Read: `{manga['count']}` Total Chapters Read: `{manga['chaptersRead']}` Total Volumes Read: `{manga['volumesRead']}` Average Score: `{manga['meanScore']}` """ btn = [] if not "user" in req: btn.append( [ InlineKeyboardButton( "Favourites", callback_data=f"myfavs_{data['id']}_yes_{display_user}", ), InlineKeyboardButton( "Activity", callback_data=f"myacc_{data['id']}_{display_user}" ), ] ) btn.append([InlineKeyboardButton("Profile", url=str(data["siteUrl"]))]) return [ f'https://img.anili.st/user/{data["id"]}?a={time.time()}', stats, InlineKeyboardMarkup(btn), ] async def update_anilist(id_, req, user, eid: int = None, status: str = None): vars_ = {"id": int(id_), "status": status} if req == "lsus": vars_ = {"id": int(eid), "status": status} if req == "dlt": vars_ = {"id": int(eid)} k = await return_json_senpai( query=( ANILIST_MUTATION if req == "lsas" else ANILIST_MUTATION_UP if req == "lsus" else ANILIST_MUTATION_DEL ), vars_=vars_, auth=True, user=int(user), ) try: ( k["data"]["SaveMediaListEntry"] if req == "lsas" else ( k["data"]["UpdateMediaListEntries"] if req == "lsus" else k["data"]["DeleteMediaListEntry"] ) ) return "ok" except KeyError: return "failed" async def check_if_adult(id_): vars_ = {"id": int(id_)} k = await return_json_senpai(query=ISADULT, vars_=vars_, auth=False) if str(k["data"]["Media"]["isAdult"]) == "True": return "True" else: return "False" #### END #### #### Jikanpy part #### async def get_scheduled(x: int = 9): base_url = "https://api.jikan.moe/v4/schedules/" day = str(day_(x if x != 9 else datetime.now().weekday())).lower() out = f"Scheduled animes for {day.capitalize()}\n\n" data = requests.get(base_url + day).json() sched_ls = data["data"] for i in sched_ls: try: title = i["titles"][0]["title"] except IndexError: title = i["title"] out += f"• `{title}`\n" return out, x if x != 9 else datetime.now().weekday() #### END #### #### chiaki part #### def get_wols(x: str): data = requests.get(f"https://chiaki.vercel.app/search2?query={x}").json() ls = [] for i in data: sls = [data[i], i] ls.append(sls) return ls def get_wo(x: int, page: int): data = requests.get(f"https://chiaki.vercel.app/get2?group_id={x}").json() msg = "Watch order for the given query is:\n\n" out = [] for i in data: out.append(f"{i['index']}. `{i['name']}`\n") total = len(out) for _ in range(50 * page): out.pop(0) out_ = "".join(out[:50]) return msg + out_, total #### END #### ##### Anime Fillers Part ##### def search_filler(query): html = requests.get("https://www.animefillerlist.com/shows").text soup = BeautifulSoup(html, "html.parser") div = soup.findAll("div", attrs={"class": "Group"}) index = {} for i in div: li = i.findAll("li") for jk in li: yum = jk.a["href"].split("/")[-1] cum = jk.text index[cum] = yum ret = {} keys = list(index.keys()) for i in range(len(keys)): if query.lower() in keys[i].lower(): ret[keys[i]] = index[keys[i]] return ret def parse_filler(filler_id): url = "https://www.animefillerlist.com/shows/" + filler_id html = requests.get(url).text soup = BeautifulSoup(html, "html.parser") div = soup.find("div", attrs={"id": "Condensed"}) all_ep = div.find_all("span", attrs={"class": "Episodes"}) if len(all_ep) == 1: ttl_ep = all_ep[0].findAll("a") total_ep = [] mix_ep = None filler_ep = None ac_ep = None for tol in ttl_ep: total_ep.append(tol.text) dict_ = { "filler_id": filler_id, "total_ep": ", ".join(total_ep), "mixed_ep": mix_ep, "filler_ep": filler_ep, "ac_ep": ac_ep, } return dict_ if len(all_ep) == 2: ttl_ep = all_ep[0].findAll("a") fl_ep = all_ep[1].findAll("a") total_ep = [] mix_ep = None ac_ep = None filler_ep = [] for tol in ttl_ep: total_ep.append(tol.text) for fol in fl_ep: filler_ep.append(fol.text) dict_ = { "filler_id": filler_id, "total_ep": ", ".join(total_ep), "mixed_ep": mix_ep, "filler_ep": ", ".join(filler_ep), "ac_ep": ac_ep, } return dict_ if len(all_ep) == 3: ttl_ep = all_ep[0].findAll("a") mxl_ep = all_ep[1].findAll("a") fl_ep = all_ep[2].findAll("a") total_ep = [] mix_ep = [] filler_ep = [] ac_ep = None for tol in ttl_ep: total_ep.append(tol.text) for fol in fl_ep: filler_ep.append(fol.text) for mol in mxl_ep: mix_ep.append(mol.text) dict_ = { "filler_id": filler_id, "total_ep": ", ".join(total_ep), "mixed_ep": ", ".join(mix_ep), "filler_ep": ", ".join(filler_ep), "ac_ep": ac_ep, } return dict_ if len(all_ep) == 4: ttl_ep = all_ep[0].findAll("a") mxl_ep = all_ep[1].findAll("a") fl_ep = all_ep[2].findAll("a") al_ep = all_ep[3].findAll("a") total_ep = [] mix_ep = [] filler_ep = [] ac_ep = [] for tol in ttl_ep: total_ep.append(tol.text) for fol in fl_ep: filler_ep.append(fol.text) for mol in mxl_ep: mix_ep.append(mol.text) for aol in al_ep: ac_ep.append(aol.text) dict_ = { "filler_id": filler_id, "total_ep": ", ".join(total_ep), "mixed_ep": ", ".join(mix_ep), "filler_ep": ", ".join(filler_ep), "ac_ep": ", ".join(ac_ep), } return dict_ @app.on_message( filters.command(["anime", f"anime{BOT_USERNAME}"], prefixes=PREFIX_HANDLER) ) @control_user async def anime_cmd(client: Client, message: Message, mdata: dict): """Search Anime Info""" text = mdata["text"].split(" ", 1) gid = mdata["chat"]["id"] try: user = mdata["from_user"]["id"] auser = mdata["from_user"]["id"] except KeyError: user = mdata["sender_chat"]["id"] ufc = await gcc(user) if ufc is not None: auser = ufc else: auser = user find_gc = await DC.find_one({"_id": gid}) if find_gc is not None and "anime" in find_gc["cmd_list"].split(): return if len(text) == 1: k = await message.reply_text( """Please give a query to search about example: /anime Sword Art Online""" ) await asyncio.sleep(5) return await k.delete() query = text[1] auth = False vars_ = {"search": query} if query.isdigit(): vars_ = {"id": int(query)} if await AUTH_USERS.find_one({"id": auser}): auth = True result = await get_anime( vars_, user=auser, auth=auth, cid=gid if gid != user else None ) if len(result) != 1: title_img, finals_ = result[0], result[1] else: k = await message.reply_text(result[0]) await asyncio.sleep(5) return await k.delete() buttons = get_btns("ANIME", result=result, user=user, auth=auth) if await SFW_GRPS.find_one({"id": gid}) and result[2].pop() == "True": await client.send_photo( gid, no_pic[random.randint(0, 4)], caption="This anime is marked 18+ and not allowed in this group", ) return try: await client.send_photo(gid, title_img, caption=finals_, reply_markup=buttons) except (WebpageMediaEmpty, WebpageCurlFailed): await clog("Mikobot", title_img, "LINK", msg=message) await client.send_photo(gid, failed_pic, caption=finals_, reply_markup=buttons) @app.on_message( filters.command(["manga", f"manga{BOT_USERNAME}"], prefixes=PREFIX_HANDLER) ) @control_user async def manga_cmd(client: Client, message: Message, mdata: dict): """Search Manga Info""" text = mdata["text"].split(" ", 1) gid = mdata["chat"]["id"] try: user = mdata["from_user"]["id"] auser = mdata["from_user"]["id"] except KeyError: user = mdata["sender_chat"]["id"] ufc = await gcc(user) if ufc is not None: auser = ufc else: auser = user find_gc = await DC.find_one({"_id": gid}) if find_gc is not None and "manga" in find_gc["cmd_list"].split(): return if len(text) == 1: k = await message.reply_text( """Please give a query to search about example: /manga Sword Art Online""" ) await asyncio.sleep(5) return await k.delete() query = text[1] qdb = rand_key() MANGA_DB[qdb] = query auth = False if await AUTH_USERS.find_one({"id": auser}): auth = True result = await get_manga( qdb, 1, auth=auth, user=auser, cid=gid if gid != user else None ) if len(result) == 1: k = await message.reply_text(result[0]) await asyncio.sleep(5) return await k.delete() pic, finals_ = result[0], result[1][0] buttons = get_btns( "MANGA", lsqry=qdb, lspage=1, user=user, result=result, auth=auth ) if await SFW_GRPS.find_one({"id": gid}) and result[2].pop() == "True": buttons = get_btns( "MANGA", lsqry=qdb, lspage=1, user=user, result=result, auth=auth, sfw="True", ) await client.send_photo( gid, no_pic[random.randint(0, 4)], caption="This manga is marked 18+ and not allowed in this group", reply_markup=buttons, ) return try: await client.send_photo(gid, pic, caption=finals_, reply_markup=buttons) except (WebpageMediaEmpty, WebpageCurlFailed): await clog("Mikobot", pic, "LINK", msg=message) await client.send_photo(gid, failed_pic, caption=finals_, reply_markup=buttons) @app.on_message( filters.command(["character", f"character{BOT_USERNAME}"], prefixes=PREFIX_HANDLER) ) @control_user async def character_cmd(client: Client, message: Message, mdata: dict): """Get Info about a Character""" text = mdata["text"].split(" ", 1) gid = mdata["chat"]["id"] try: user = mdata["from_user"]["id"] auser = mdata["from_user"]["id"] except KeyError: user = mdata["sender_chat"]["id"] ufc = await gcc(user) if ufc is not None: auser = ufc else: auser = user find_gc = await DC.find_one({"_id": gid}) if find_gc is not None and "character" in find_gc["cmd_list"].split(): return if len(text) == 1: k = await message.reply_text( "Please give a query to search about\nexample: /character Luffy" ) await asyncio.sleep(5) return await k.delete() query = text[1] qdb = rand_key() CHAR_DB[qdb] = query auth = False if await AUTH_USERS.find_one({"id": auser}): auth = True result = await get_character(qdb, 1, auth=auth, user=auser) if len(result) == 1: k = await message.reply_text(result[0]) await asyncio.sleep(5) return await k.delete() img = result[0] cap_text = result[1][0] buttons = get_btns( "CHARACTER", user=user, lsqry=qdb, lspage=1, result=result, auth=auth ) try: await client.send_photo(gid, img, caption=cap_text, reply_markup=buttons) except (WebpageMediaEmpty, WebpageCurlFailed): await clog("Mikobot", img, "LINK", msg=message) await client.send_photo(gid, failed_pic, caption=cap_text, reply_markup=buttons) @app.on_message( filters.command(["anilist", f"anilist{BOT_USERNAME}"], prefixes=PREFIX_HANDLER) ) @control_user async def anilist_cmd(client: Client, message: Message, mdata: dict): text = mdata["text"].split(" ", 1) gid = mdata["chat"]["id"] try: user = mdata["from_user"]["id"] auser = mdata["from_user"]["id"] except KeyError: user = mdata["sender_chat"]["id"] ufc = await gcc(user) if ufc is not None: auser = ufc else: auser = user find_gc = await DC.find_one({"_id": gid}) if find_gc is not None and "anilist" in find_gc["cmd_list"].split(): return if len(text) == 1: k = await message.reply_text( "Please give a query to search about\nexample: /anilist Sword Art Online" ) await asyncio.sleep(5) return await k.delete() query = text[1] qdb = rand_key() ANIME_DB[qdb] = query auth = False if await AUTH_USERS.find_one({"id": auser}): auth = True result = await get_anilist( qdb, 1, auth=auth, user=auser, cid=gid if gid != user else None ) if len(result) == 1: k = await message.reply_text(result[0]) await asyncio.sleep(5) return await k.delete() pic, msg = result[0], result[1][0] buttons = get_btns( "ANIME", lsqry=qdb, lspage=1, result=result, user=user, auth=auth ) if await SFW_GRPS.find_one({"id": gid}) and result[2].pop() == "True": buttons = get_btns( "ANIME", lsqry=qdb, lspage=1, result=result, user=user, auth=auth, sfw="True", ) await client.send_photo( gid, no_pic[random.randint(0, 4)], caption="This anime is marked 18+ and not allowed in this group", reply_markup=buttons, ) return try: await client.send_photo(gid, pic, caption=msg, reply_markup=buttons) except (WebpageMediaEmpty, WebpageCurlFailed): await clog("Mikobot", pic, "LINK", msg=message) await client.send_photo(gid, failed_pic, caption=msg, reply_markup=buttons) @app.on_message(filters.command(["top", f"top{BOT_USERNAME}"], prefixes=PREFIX_HANDLER)) @control_user async def top_tags_cmd(client: Client, message: Message, mdata: dict): query = mdata["text"].split(" ", 1) gid = mdata["chat"]["id"] find_gc = await DC.find_one({"_id": gid}) if find_gc is not None and "top" in find_gc["cmd_list"].split(): return get_tag = "None" if len(query) == 2: get_tag = query[1] try: user = mdata["from_user"]["id"] except KeyError: user = mdata["sender_chat"]["id"] result = await get_top_animes(get_tag, 1, user) if len(result) == 1: k = await message.reply_text(result[0]) await asyncio.sleep(5) return await k.delete() if await SFW_GRPS.find_one({"id": gid}) and str(result[0][1]) == "True": return await message.reply_text("No nsfw stuff allowed in this group!!!") msg, buttons = result await client.send_message( gid, msg[0], reply_markup=buttons if buttons != "" else None ) @app.on_message( filters.command(["studio", f"studio{BOT_USERNAME}"], prefixes=PREFIX_HANDLER) ) @control_user async def studio_cmd(client: Client, message: Message, mdata: dict): text = mdata["text"].split(" ", 1) gid = mdata["chat"]["id"] find_gc = await DC.find_one({"_id": gid}) if find_gc is not None and "studio" in find_gc["cmd_list"].split(): return if len(text) == 1: x = await message.reply_text( "Please give a query to search about!!!\nExample: /studio ufotable" ) await asyncio.sleep(5) await x.delete() return query = text[1] qdb = rand_key() STUDIO_DB[qdb] = query auth = False try: user = mdata["from_user"]["id"] auser = mdata["from_user"]["id"] except KeyError: user = mdata["sender_chat"]["id"] ufc = await gcc(user) if ufc is not None: auser = ufc else: auser = user if await AUTH_USERS.find_one({"id": auser}): auth = True result = await get_studios(qdb, 1, user=auser, duser=user, auth=auth) if len(result) == 1: x = await message.reply_text("No results found!!!") await asyncio.sleep(5) return await x.delete() msg, buttons = result[0], result[1] await client.send_message(gid, msg, reply_markup=buttons if buttons != "" else None) @app.on_message( filters.command(["airing", f"airing{BOT_USERNAME}"], prefixes=PREFIX_HANDLER) ) @control_user async def airing_cmd(client: Client, message: Message, mdata: dict): """Get Airing Detail of Anime""" text = mdata["text"].split(" ", 1) gid = mdata["chat"]["id"] find_gc = await DC.find_one({"_id": gid}) if find_gc is not None and "airing" in find_gc["cmd_list"].split(): return if len(text) == 1: k = await message.reply_text( """Please give a query to search about example: /airing Sword Art Online""" ) await asyncio.sleep(5) return await k.delete() query = text[1] qdb = rand_key() AIRING_DB[qdb] = query auth = False try: user = mdata["from_user"]["id"] auser = mdata["from_user"]["id"] except KeyError: user = mdata["sender_chat"]["id"] ufc = await gcc(user) if ufc is not None: auser = ufc else: auser = user if await AUTH_USERS.find_one({"id": auser}): auth = True result = await get_airing(qdb, 1, auth=auth, user=auser) if len(result) == 1: k = await message.reply_text(result[0]) await asyncio.sleep(5) return await k.delete() coverImg, out = result[0] btn = get_btns("AIRING", user=user, result=result, auth=auth, lsqry=qdb, lspage=1) if await SFW_GRPS.find_one({"id": gid}) and result[2].pop() == "True": btn = get_btns( "AIRING", user=user, result=result, auth=auth, lsqry=qdb, lspage=1, sfw="True", ) await client.send_photo( gid, no_pic[random.randint(0, 4)], caption="This anime is marked 18+ and not allowed in this group", reply_markup=btn, ) return try: await client.send_photo(gid, coverImg, caption=out, reply_markup=btn) except (WebpageMediaEmpty, WebpageCurlFailed): await clog("Mikobot", coverImg, "LINK", msg=message) await client.send_photo(gid, failed_pic, caption=out, reply_markup=btn) setting_text = """ This allows you to change group settings NSFW toggle switches on filtering of 18+ marked content Airing notifications notifies about airing of anime in recent Crunchyroll updates will toggle notifications about release of animes on crunchyroll site Subsplease updates will toggle notifications about release of animes on subsplease site Click Headlines button to enable headlines. You can choose from given sources""" @app.on_message( ~filters.private & filters.command( ["anisettings", f"anisettings{BOT_USERNAME}"], prefixes=PREFIX_HANDLER ) ) @control_user async def settings_cmd(client: Client, message: Message, mdata: dict): cid = mdata["chat"]["id"] try: user = mdata["from_user"]["id"] except KeyError: user = mdata["sender_chat"]["id"] type_ = mdata["chat"]["type"] try: status = (await app.get_chat_member(cid, user)).status except UserNotParticipant: status = None if ( user in BOT_OWNER or status in [ADMINISTRATOR, CHAT_OWNER] or type_ == ChatType.CHANNEL or user == cid ): sfw = "NSFW: Allowed" if await SFW_GRPS.find_one({"id": cid}): sfw = "NSFW: Not Allowed" notif = "Airing notifications: OFF" if await AG.find_one({"_id": cid}): notif = "Airing notifications: ON" cr = "Crunchyroll Updates: OFF" if await CG.find_one({"_id": cid}): cr = "Crunchyroll Updates: ON" sp = "Subsplease Updates: OFF" if await SG.find_one({"_id": cid}): sp = "Subsplease Updates: ON" await message.reply_text( text=setting_text, reply_markup=InlineKeyboardMarkup( [ [ InlineKeyboardButton( text=sfw, callback_data=f"settogl_sfw_{cid}" ) ], [ InlineKeyboardButton( text=notif, callback_data=f"settogl_notif_{cid}" ) ], [InlineKeyboardButton(text=cr, callback_data=f"settogl_cr_{cid}")], [InlineKeyboardButton(text=sp, callback_data=f"settogl_sp_{cid}")], [ InlineKeyboardButton( text="Headlines", callback_data=f"headlines_call_{cid}" ) ], [ InlineKeyboardButton( text="Change UI", callback_data=f"cui_call_{cid}" ) ], ] ), ) @app.on_message( filters.command(["browse", f"browse{BOT_USERNAME}"], prefixes=PREFIX_HANDLER) ) @control_user async def browse_cmd(client: Client, message: Message, mdata: dict): try: user = mdata["from_user"]["id"] except KeyError: user = mdata["sender_chat"]["id"] gid = mdata["chat"]["id"] find_gc = await DC.find_one({"_id": gid}) if find_gc is not None and "browse" in find_gc["cmd_list"].split(): return up = "Upcoming" tr = "• Trending •" pp = "Popular" btns = [ [ InlineKeyboardButton(tr, callback_data=f"browse_{tr.lower()}_{user}"), InlineKeyboardButton(pp, callback_data=f"browse_{pp.lower()}_{user}"), InlineKeyboardButton(up, callback_data=f"browse_{up.lower()}_{user}"), ] ] msg = await browse_("trending") await client.send_message(gid, msg, reply_markup=InlineKeyboardMarkup(btns)) @app.on_message( filters.command( ["gettags", f"gettags{BOT_USERNAME}", "getgenres", f"getgenres{BOT_USERNAME}"], prefixes=PREFIX_HANDLER, ) ) @control_user async def list_tags_genres_cmd(client, message: Message, mdata: dict): gid = mdata["chat"]["id"] text = mdata["text"] find_gc = await DC.find_one({"_id": gid}) if find_gc is not None and "gettags" in ( text.split()[0] and find_gc["cmd_list"].split() ): return if find_gc is not None and "getgenres" in ( text.split()[0] and find_gc["cmd_list"].split() ): return if await SFW_GRPS.find_one({"id": gid}) and "nsfw" in text: return await message.reply_text("No nsfw allowed here!!!") msg = ( (await get_all_tags(text)) if "gettags" in text.split()[0] else (await get_all_genres()) ) await message.reply_text(msg) @app.on_callback_query(filters.regex(pattern=r"page_(.*)")) @check_user async def page_btn(client: Client, cq: CallbackQuery, cdata: dict): kek, media, query, page, auth, user = cq.data.split("_") gid = cdata["message"]["chat"]["id"] if media == "ANIME": try: ANIME_DB[query] except KeyError: return await cq.answer("Query Expired!!!\nCreate new one", show_alert=True) if media == "MANGA": try: MANGA_DB[query] except KeyError: return await cq.answer("Query Expired!!!\nCreate new one", show_alert=True) if media == "CHARACTER": try: CHAR_DB[query] except KeyError: return await cq.answer("Query Expired!!!\nCreate new one", show_alert=True) if media == "AIRING": try: AIRING_DB[query] except KeyError: return await cq.answer("Query Expired!!!\nCreate new one", show_alert=True) authbool = bool(1) if auth == "True" else bool(0) if "-100" in str(user): auser = await gcc(user) else: auser = user if media in ["ANIME", "MANGA"]: result = await (get_anilist if media == "ANIME" else get_manga)( query, int(page), auth=authbool, user=int(auser), cid=gid if gid != user else None, ) else: result = await (get_character if media == "CHARACTER" else get_airing)( query, int(page), auth=authbool, user=int(auser) ) if "No results Found" in result: await cq.answer("No more results available!!!", show_alert=True) return pic, msg = result[0], result[1][0] if media == "AIRING": pic, msg = result[0][0], result[0][1] button = get_btns( media, lsqry=query, lspage=int(page), result=result, user=user, auth=authbool ) if ( await SFW_GRPS.find_one({"id": gid}) and media != "CHARACTER" and result[2].pop() == "True" ): button = get_btns( media, lsqry=query, lspage=int(page), result=result, user=user, auth=authbool, sfw="True", ) await cq.edit_message_media( InputMediaPhoto( no_pic[random.randint(0, 4)], caption=""" This material is marked 18+ and not allowed in this group""", ), reply_markup=button, ) return try: await cq.edit_message_media( InputMediaPhoto(pic, caption=msg), reply_markup=button ) except (WebpageMediaEmpty, WebpageCurlFailed): await clog("Mikobot", pic, "LINK", msg=cq) await cq.edit_message_media( InputMediaPhoto(failed_pic, caption=msg), reply_markup=button ) await cq.answer() @app.on_callback_query(filters.regex(pattern=r"pgstudio_(.*)")) @check_user async def studio_pg_btn(client: Client, cq: CallbackQuery, cdata: dict): kek, page, qry, auth, user = cdata["data"].split("_") authbool = bool(1) if auth == "True" else bool(0) try: STUDIO_DB[qry] except KeyError: return await cq.answer("Query Expired!!!\nCreate new one", show_alert=True) if "-100" in str(user): auser = await gcc(user) else: auser = user result = await get_studios(qry, page=page, user=auser, duser=user, auth=authbool) if len(result) == 1: return await cq.answer("No more results available!!!", show_alert=True) msg, buttons = result[0], result[1] await cq.edit_message_text(msg, reply_markup=buttons) @app.on_callback_query(filters.regex(pattern=r"stuani_(.*)")) @check_user async def studio_ani_btn(client: Client, cq: CallbackQuery, cdata: dict): kek, page, id_, rp, qry, auth, user = cdata["data"].split("_") authbool = bool(1) if auth == "True" else bool(0) if "-100" in str(user): auser = await gcc(user) else: auser = user result = await get_studio_animes(id_, page, qry, rp, auser, user, authbool) if len(result) == 1: return await cq.answer("No results available!!!", show_alert=True) msg, buttons = result[0], result[1] await cq.edit_message_text(msg, reply_markup=buttons) @app.on_callback_query(filters.regex(pattern=r"btn_(.*)")) @check_user async def anime_btn(client: Client, cq: CallbackQuery, cdata: dict): await cq.answer() query = cdata["data"].split("_") idm = query[1] user = int(query.pop()) if "-100" in str(user): auser = await gcc(user) else: auser = user authbool = bool(1) if query[2] == "True" else bool(0) vars_ = {"id": int(idm)} cid = cdata["message"]["chat"]["id"] result = await get_anime( vars_, auth=authbool, user=auser, cid=cid if cid != user else None ) pic, msg = result[0], result[1] btns = get_btns("ANIME", result=result, user=user, auth=authbool) try: await cq.edit_message_media( InputMediaPhoto(pic, caption=msg), reply_markup=btns ) except (WebpageMediaEmpty, WebpageCurlFailed): await clog("Mikobot", pic, "LINK", msg=cq) await cq.edit_message_media( InputMediaPhoto(failed_pic, caption=msg), reply_markup=btns ) @app.on_callback_query(filters.regex(pattern=r"topanimu_(.*)")) @check_user async def top_tags_btn(client: Client, cq: CallbackQuery, cdata: dict): await cq.answer() kek, gnr, page, user = cdata["data"].split("_") result = await get_top_animes(gnr, page=page, user=user) msg, buttons = result[0][0], result[1] await cq.edit_message_text(msg, reply_markup=buttons) @app.on_callback_query(filters.regex(pattern=r"settogl_(.*)")) async def nsfw_toggle_btn(client: Client, cq: CallbackQuery): cus = cq.from_user.id gid = cq.data.split("_").pop() try: k = (await client.get_chat_member(gid, cus)).status except UserNotParticipant: await cq.answer() return if cus not in BOT_OWNER and k == MEMBER: await cq.answer( "You don't have enough permissions to change this!!!", show_alert=True ) return query = cq.data.split("_") if await SFW_GRPS.find_one({"id": int(query[2])}): sfw = "NSFW: Not Allowed" else: sfw = "NSFW: Allowed" if await AG.find_one({"_id": int(query[2])}): notif = "Airing notifications: ON" else: notif = "Airing notifications: OFF" if await CG.find_one({"_id": int(query[2])}): cr = "Crunchyroll Updates: ON" else: cr = "Crunchyroll Updates: OFF" if await SG.find_one({"_id": int(query[2])}): sp = "Subsplease Updates: ON" else: sp = "Subsplease Updates: OFF" if query[1] == "sfw": if await SFW_GRPS.find_one({"id": int(query[2])}): await SFW_GRPS.find_one_and_delete({"id": int(query[2])}) sfw = "NSFW: Allowed" else: await SFW_GRPS.insert_one({"id": int(query[2])}) sfw = "NSFW: Not Allowed" if query[1] == "notif": if await AG.find_one({"_id": int(query[2])}): await AG.find_one_and_delete({"_id": int(query[2])}) notif = "Airing notifications: OFF" else: await AG.insert_one({"_id": int(query[2])}) notif = "Airing notifications: ON" if query[1] == "cr": if await CG.find_one({"_id": int(query[2])}): await CG.find_one_and_delete({"_id": int(query[2])}) cr = "Crunchyroll Updates: OFF" else: await CG.insert_one({"_id": int(query[2])}) cr = "Crunchyroll Updates: ON" if query[1] == "sp": if await SG.find_one({"_id": int(query[2])}): await SG.find_one_and_delete({"_id": int(query[2])}) sp = "Subsplease Updates: OFF" else: await SG.insert_one({"_id": int(query[2])}) sp = "Subsplease Updates: ON" btns = InlineKeyboardMarkup( [ [InlineKeyboardButton(text=sfw, callback_data=f"settogl_sfw_{query[2]}")], [ InlineKeyboardButton( text=notif, callback_data=f"settogl_notif_{query[2]}" ) ], [InlineKeyboardButton(text=cr, callback_data=f"settogl_cr_{query[2]}")], [InlineKeyboardButton(text=sp, callback_data=f"settogl_sp_{query[2]}")], [ InlineKeyboardButton( text="Headlines", callback_data=f"headlines_call_{query[2]}" ) ], [ InlineKeyboardButton( text="Change UI", callback_data=f"cui_call_{query[2]}" ) ], ] ) await cq.answer() if query[1] == "call": await cq.edit_message_text(text=setting_text, reply_markup=btns) await cq.edit_message_reply_markup(reply_markup=btns) @app.on_callback_query(filters.regex(pattern=r"myacc_(.*)")) @check_user async def flex_btn(client: Client, cq: CallbackQuery, cdata: dict): await cq.answer() query = cdata["data"].split("_")[1] user = cdata["data"].split("_").pop() if "-100" in str(user): auser = await gcc(user) else: auser = user result = await get_user_activity(int(query), user=int(auser), duser=int(user)) pic, msg, btns = result try: await cq.edit_message_media( InputMediaPhoto(pic, caption=msg), reply_markup=btns ) except (WebpageMediaEmpty, WebpageCurlFailed): await clog("Mikobot", pic, "LINK", msg=cq) await cq.edit_message_media( InputMediaPhoto(failed_pic, caption=msg), reply_markup=btns ) @app.on_callback_query(filters.regex(pattern=r"myfavs_(.*)")) @check_user async def list_favourites_btn(client: Client, cq: CallbackQuery, cdata: dict): await cq.answer() q = cdata["data"].split("_") btn = [ [ InlineKeyboardButton( "ANIME", callback_data=f"myfavqry_ANIME_{q[1]}_1_{q[2]}_{q[3]}" ), InlineKeyboardButton( "CHARACTER", callback_data=f"myfavqry_CHAR_{q[1]}_1_{q[2]}_{q[3]}" ), InlineKeyboardButton( "MANGA", callback_data=f"myfavqry_MANGA_{q[1]}_1_{q[2]}_{q[3]}" ), ] ] if q[2] == "yes": btn.append([InlineKeyboardButton("BACK", callback_data=f"getusrbc_{q[3]}")]) else: btn.append( [InlineKeyboardButton("PROFILE", url=f"https://anilist.co/user/{q[1]}")] ) try: await cq.edit_message_media( InputMediaPhoto( f"https://img.anili.st/user/{q[1]}?a={time.time()}", caption="Choose one of the below options", ), reply_markup=InlineKeyboardMarkup(btn), ) except (WebpageMediaEmpty, WebpageCurlFailed): await clog( "Mikobot", f"https://img.anili.st/user/{q[1]}?a={time.time()}", "LINK", msg=cq, ) await cq.edit_message_media( InputMediaPhoto(failed_pic, caption="Choose one of the below options"), reply_markup=InlineKeyboardMarkup(btn), ) @app.on_callback_query(filters.regex(pattern=r"myfavqry_(.*)")) @check_user async def favourites_btn(client: Client, cq: CallbackQuery, cdata: dict): await cq.answer() q = cdata["data"].split("_") if "-100" in str(q[5]): auser = await gcc(q[5]) else: auser = q[5] pic, msg, btns = await get_user_favourites( q[2], int(auser), q[1], q[3], q[4], duser=int(q[5]) ) try: await cq.edit_message_media( InputMediaPhoto(pic, caption=msg), reply_markup=btns ) except (WebpageMediaEmpty, WebpageCurlFailed): await clog("Mikobot", pic, "LINK", msg=cq) await cq.edit_message_media( InputMediaPhoto(failed_pic, caption=msg), reply_markup=btns ) @app.on_callback_query(filters.regex(pattern=r"getusrbc_(.*)")) @check_user async def get_user_back_btn(client: Client, cq: CallbackQuery, cdata: dict): await cq.answer() query = cdata["data"].split("_")[1] if "-100" in str(query): auser = await gcc(query) else: auser = query result = await get_user(None, "flex", user=int(auser), display_user=query) pic, msg, btns = result try: await cq.edit_message_media( InputMediaPhoto(pic, caption=msg), reply_markup=btns ) except (WebpageMediaEmpty, WebpageCurlFailed): await clog("Mikobot", pic, "LINK", msg=cq) await cq.edit_message_media( InputMediaPhoto(failed_pic, caption=msg), creply_markup=btns ) @app.on_callback_query(filters.regex(pattern=r"fav_(.*)")) @check_user async def toggle_favourites_btn(client: Client, cq: CallbackQuery, cdata: dict): query = cdata["data"].split("_") if query[1] == "ANIME" and len(query) > 4: try: ANIME_DB[query[3]] except KeyError: return await cq.answer("Query Expired!!!\nCreate new one", show_alert=True) if query[1] == "MANGA": try: MANGA_DB[query[3]] except KeyError: return await cq.answer("Query Expired!!!\nCreate new one", show_alert=True) if query[1] == "CHARACTER": try: CHAR_DB[query[3]] except KeyError: return await cq.answer("Query Expired!!!\nCreate new one", show_alert=True) if query[1] == "STUDIO": try: STUDIO_DB[query[3]] except KeyError: return await cq.answer("Query Expired!!!\nCreate new one", show_alert=True) idm = int(query[2]) user = int(query.pop()) if "-100" in str(user): auser = await gcc(user) else: auser = user gid = cdata["message"]["chat"]["id"] rslt = await toggle_favourites(id_=idm, media=query[1], user=auser) if rslt == "ok": await cq.answer("Updated", show_alert=True) else: return await cq.answer("Failed to update!!!", show_alert=True) result = ( ( await get_anime( {"id": idm}, auth=True, user=auser, cid=gid if gid != user else None ) ) if query[1] == "ANIME" and len(query) == 3 else ( ( await get_anilist( query[3], page=int(query[4]), auth=True, user=auser, cid=gid if gid != user else None, ) ) if query[1] == "ANIME" and len(query) != 3 else ( ( await get_manga( query[3], page=int(query[4]), auth=True, user=auser, cid=gid if gid != user else None, ) ) if query[1] == "MANGA" else ( ( await get_airing( query[3], auth=True, user=auser, ind=int(query[4]) ) ) if query[1] == "AIRING" else ( ( await get_character( query[3], int(query[4]), auth=True, user=auser ) ) if query[1] == "CHARACTER" else ( await get_studios( query[3], int(query[4]), user=auser, auth=True, duser=user, ) ) ) ) ) ) ) if query[1] == "STUDIO": return await cq.edit_message_text(result[0], reply_markup=result[1]) pic, msg = ( (result[0], result[1]) if query[1] == "ANIME" and len(query) == 3 else (result[0]) if query[1] == "AIRING" else (result[0], result[1][0]) ) btns = get_btns( query[1], result=result, user=user, auth=True, lsqry=query[3] if len(query) != 3 else None, lspage=int(query[4]) if len(query) != 3 else None, ) try: await cq.edit_message_media( InputMediaPhoto(pic, caption=msg), reply_markup=btns ) except (WebpageMediaEmpty, WebpageCurlFailed): await clog("Mikobot", pic, "LINK", msg=cq) await cq.edit_message_media( InputMediaPhoto(failed_pic, caption=msg), reply_markup=btns ) @app.on_callback_query(filters.regex(pattern=r"(lsadd|lsupdt)_(.*)")) @check_user async def list_update_anilist_btn(client: Client, cq: CallbackQuery, cdata: dict): stts_ls = ["COMPLETED", "CURRENT", "PLANNING", "DROPPED", "PAUSED", "REPEATING"] query = cdata["data"].split("_") btns = [] row = [] for i in stts_ls: row.append( InlineKeyboardButton( text=i, callback_data=( cq.data.replace("lsadd", f"lsas_{i}") if query[0] == "lsadd" else cq.data.replace("lsupdt", f"lsus_{i}") ), ) ) if len(row) == 3: btns.append(row) row = [] if query[0] == "lsupdt": btns.append( [ InlineKeyboardButton( "DELETE", callback_data=cq.data.replace("lsupdt", f"dlt_{i}") ) ] ) await cq.edit_message_reply_markup(reply_markup=InlineKeyboardMarkup(btns)) @app.on_callback_query( filters.regex(pattern=r"browse_(upcoming|trending|popular)_(.*)") ) @check_user async def browse_btn(client: Client, cq: CallbackQuery, cdata: dict): query = cdata["data"].split("_") if "•" in query[1]: return msg = await browse_(query[1]) up = "Upcoming" if query[1] != "upcoming" else "• Upcoming •" tr = "Trending" if query[1] != "trending" else "• Trending •" pp = "Popular" if query[1] != "popular" else "• Popular •" btns = [ [ InlineKeyboardButton(tr, callback_data=f"browse_{tr.lower()}_{query[2]}"), InlineKeyboardButton(pp, callback_data=f"browse_{pp.lower()}_{query[2]}"), InlineKeyboardButton(up, callback_data=f"browse_{up.lower()}_{query[2]}"), ] ] await cq.edit_message_text(msg, reply_markup=InlineKeyboardMarkup(btns)) @app.on_callback_query(filters.regex(pattern=r"(lsas|lsus|dlt)_(.*)")) @check_user async def update_anilist_btn(client: Client, cq: CallbackQuery, cdata: dict): query = cdata["data"].split("_") if query[2] == "ANIME": if len(query) == 7: try: ANIME_DB[query[4]] except KeyError: return await cq.answer( "Query Expired!!!\nCreate new one", show_alert=True ) if len(query) == 8: try: ANIME_DB[query[5]] except KeyError: return await cq.answer( "Query Expired!!!\nCreate new one", show_alert=True ) if query[2] == "MANGA": if len(query) == 7: try: MANGA_DB[query[4]] except KeyError: return await cq.answer( "Query Expired!!!\nCreate new one", show_alert=True ) if len(query) == 8: try: MANGA_DB[query[5]] except KeyError: return await cq.answer( "Query Expired!!!\nCreate new one", show_alert=True ) idm = int(query[3]) user = int(query.pop()) if "-100" in str(user): auser = await gcc(user) else: auser = user gid = cdata["message"]["chat"]["id"] eid = None if query[0] != "lsas": eid = int(query[4]) rslt = await update_anilist( id_=idm, req=query[0], status=query[1], user=auser, eid=eid ) if rslt == "ok": await cq.answer("Updated", show_alert=True) else: await cq.answer( "Something unexpected happened and operation failed successfully", show_alert=True, ) return result = ( ( await get_anime( {"id": idm}, auth=True, user=auser, cid=gid if gid != user else None ) ) if query[2] == "ANIME" and (len(query) == 4 or len(query) == 5) else ( ( await get_anilist( query[4], page=int(query[5]), auth=True, user=auser, cid=gid if gid != user else None, ) ) if query[2] == "ANIME" and len(query) == 6 else ( ( await get_anilist( query[5], page=int(query[6]), auth=True, user=auser, cid=gid if gid != user else None, ) ) if query[2] == "ANIME" and len(query) == 7 else ( ( await get_manga( query[4], page=int(query[5]), auth=True, user=auser, cid=gid if gid != user else None, ) ) if query[2] == "MANGA" and len(query) == 6 else ( ( await get_manga( query[5], page=int(query[6]), auth=True, user=auser, cid=gid if gid != user else None, ) ) if query[2] == "MANGA" and len(query) == 7 else ( await get_airing( query[4] if eid is None else query[5], auth=True, user=auser, ind=int(query[5] if eid is None else query[6]), ) ) ) ) ) ) ) pic, msg = ( (result[0], result[1]) if query[2] == "ANIME" and (len(query) == 4 or len(query) == 5) else (result[0]) if query[2] == "AIRING" else (result[0], result[1][0]) ) btns = get_btns( query[2], result=result, user=user, auth=True, lsqry=query[4] if len(query) == 6 else query[5] if len(query) == 7 else None, lspage=( int(query[5]) if len(query) == 6 else int(query[6]) if len(query) == 7 else None ), ) try: await cq.edit_message_media( InputMediaPhoto(pic, caption=msg), reply_markup=btns ) except (WebpageMediaEmpty, WebpageCurlFailed): await clog("Mikobot", pic, "LINK", msg=cq) await cq.edit_message_media( InputMediaPhoto(failed_pic, caption=msg), reply_markup=btns ) @app.on_callback_query(filters.regex(pattern=r"(desc|ls|char)_(.*)")) @check_user async def additional_info_btn(client: Client, cq: CallbackQuery, cdata: dict): q = cdata["data"].split("_") kek, qry, ctgry = q[0], q[1], q[2] info = ( "Description" if kek == "desc" else "Series List" if kek == "ls" else "Characters List" ) page = 0 lsqry = f"_{q[3]}" if len(q) > 6 else "" lspg = f"_{q[4]}" if len(q) > 6 else "" if kek == "char": page = q[6] if len(q) > 6 else q[4] rjsdata = await get_additional_info(qry, ctgry, kek, page=int(page)) pic, result = rjsdata[0], rjsdata[1] button = [] spoiler = False bot = BOT_USERNAME if result is None: await cq.answer("No description available!!!", show_alert=True) return if "~!" in result and "!~" in result: result = re.sub(r"~!.*!~", "[Spoiler]", result) spoiler = True button.append( [ InlineKeyboardButton( text="VIEW SPOILER", url=f"https://t.me/{bot}/?astart=des_{ctgry}_{qry}_desc", ) ] ) if len(result) > 1000: result = result[:940] + "..." if spoiler is False: result += "\n\nFor more info click below given button" button.append( [ InlineKeyboardButton( text="MORE INFO", url=f"https://t.me/{bot}/?astart=des_{ctgry}_{qry}_{kek}", ) ] ) add_ = "" user = q.pop() if kek == "char": btndata = rjsdata[2] if btndata["lastPage"] != 1: qs = q[5] if len(q) != 5 else q[3] pre = f"{kek}_{qry}_{ctgry}{lsqry}{lspg}_{qs}_{int(page)-1}_{user}" nex = f"{kek}_{qry}_{ctgry}{lsqry}{lspg}_{qs}_{int(page)+1}_{user}" if page == "1": button.append([InlineKeyboardButton(text="NEXT", callback_data=nex)]) elif btndata["lastPage"] == int(page): button.append([InlineKeyboardButton(text="PREV", callback_data=pre)]) else: button.append( [ InlineKeyboardButton(text="PREV", callback_data=pre), InlineKeyboardButton(text="NEXT", callback_data=nex), ] ) add_ = f"\n\nTotal Characters: {btndata['total']}" msg = f"{info}:\n\n{result+add_}" cbd = ( f"btn_{qry}_{q[3]}_{user}" if len(q) <= 5 else ( f"page_ANIME{lsqry}{lspg}_{q[5]}_{user}" if ctgry == "ANI" else f"page_CHARACTER{lsqry}{lspg}_{q[5]}_{user}" ) ) button.append([InlineKeyboardButton(text="BACK", callback_data=cbd)]) try: await cq.edit_message_media( InputMediaPhoto(pic, caption=msg), reply_markup=InlineKeyboardMarkup(button) ) except (WebpageMediaEmpty, WebpageCurlFailed): await clog("Mikobot", pic, "LINK", msg=cq) await cq.edit_message_media( InputMediaPhoto(failed_pic, caption=msg), reply_markup=InlineKeyboardMarkup(button), ) await cq.answer() @app.on_callback_query(filters.regex(pattern=r"lsc_(.*)")) @check_user async def featured_in_btn(client: Client, cq: CallbackQuery, cdata: dict): kek, idm, qry, pg, auth, usr = cdata["data"].split("_") result = await get_featured_in_lists(int(idm), "ANI") req = "lscm" if result[0] is False: result = await get_featured_in_lists(int(idm), "MAN") req = None if result[0] is False: await cq.answer("No Data Available!!!", show_alert=True) return [msg, total], pic = result button = [] totalpg, kek = divmod(total, 15) if kek != 0: totalpg + 1 if total > 15: button.append( [ InlineKeyboardButton( text="NEXT", callback_data=f"lsca_{idm}_1_{qry}_{pg}_{auth}_{usr}" ) ] ) if req is not None: button.append( [ InlineKeyboardButton( text="MANGA", callback_data=f"lscm_{idm}_0_{qry}_{pg}_{auth}_{usr}" ) ] ) button.append( [ InlineKeyboardButton( text="BACK", callback_data=f"page_CHARACTER_{qry}_{pg}_{auth}_{usr}" ) ] ) try: await cq.edit_message_media( InputMediaPhoto(pic, caption=msg), reply_markup=InlineKeyboardMarkup(button) ) except (WebpageMediaEmpty, WebpageCurlFailed): await clog("Mikobot", pic, "LINK", msg=cq) await cq.edit_message_media( InputMediaPhoto(failed_pic, caption=msg), reply_markup=InlineKeyboardMarkup(button), ) @app.on_callback_query(filters.regex(pattern=r"lsc(a|m)_(.*)")) @check_user async def featured_in_switch_btn(client: Client, cq: CallbackQuery, cdata: dict): req, idm, reqpg, qry, pg, auth, user = cdata["data"].split("_") result = await get_featured_in_lists( int(idm), "MAN" if req == "lscm" else "ANI", page=int(reqpg) ) reqb = "lsca" if req == "lscm" else "lscm" bt = "Anime" if req == "lscm" else "Manga" if result[0] is False: await cq.answer("No Data Available!!!", show_alert=True) return [msg, total], pic = result totalpg, kek = divmod(total, 15) if kek != 0: totalpg + 1 button = [] if total > 15: nex = f"{req}_{idm}_{int(reqpg)+1}_{qry}_{pg}_{auth}_{user}" bac = f"{req}_{idm}_{int(reqpg)-1}_{qry}_{pg}_{auth}_{user}" if int(reqpg) == 0: button.append([InlineKeyboardButton(text="NEXT", callback_data=nex)]) elif int(reqpg) == totalpg: button.append([InlineKeyboardButton(text="BACK", callback_data=bac)]) else: button.append( [ InlineKeyboardButton(text="BACK", callback_data=bac), InlineKeyboardButton(text="NEXT", callback_data=nex), ] ) button.append( [ InlineKeyboardButton( text=f"{bt}", callback_data=f"{reqb}_{idm}_0_{qry}_{pg}_{auth}_{user}" ) ] ) button.append( [ InlineKeyboardButton( text="BACK", callback_data=f"page_CHARACTER_{qry}_{pg}_{auth}_{user}" ) ] ) try: await cq.edit_message_media( InputMediaPhoto(pic, caption=msg), reply_markup=InlineKeyboardMarkup(button) ) except (WebpageMediaEmpty, WebpageCurlFailed): await clog("Mikobot", pic, "LINK", msg=cq) await cq.edit_message_media( InputMediaPhoto(failed_pic, caption=msg), reply_markup=InlineKeyboardMarkup(button), ) headlines_text = """ Turn LiveChart option on to get news feeds from livechart.me Turn MyAnimeList option on to get news feeds from myanimelist.net For Auto Pin and Auto Unpin features, give the bot "Pin Message" and "Delete Message" perms Auto Unpin can be customized, click on the button to see available options """ @app.on_callback_query(filters.regex(pattern=r"headlines_(.*)")) async def headlines_btn(client: Client, cq: CallbackQuery): cus = cq.from_user.id qry = cq.data.split("_")[1] gid = int(cq.data.split("_")[2]) try: k = (await client.get_chat_member(gid, cus)).status except UserNotParticipant: await cq.answer() return if cus not in BOT_OWNER and k == MEMBER: await cq.answer( "You don't have enough permissions to change this!!!", show_alert=True ) return lcdata = await HD.find_one({"_id": gid}) maldata = await MHD.find_one({"_id": gid}) lchd = "LiveChart: OFF" malhd = "MyAnimeList: OFF" malhdpin = lchdpin = "Auto Pin: OFF" malpin = lcpin = None if lcdata: lchd = "LiveChart: ON" try: lcpin = lcdata["pin"] lchdpin = f"Auto Pin: {lcpin}" except KeyError: pass if maldata: malhd = "MyAnimeList: ON" try: malpin = maldata["pin"] malhdpin = f"Auto Pin: {malpin}" except KeyError: pass if "mal" in qry: data = maldata pin = malpin pin_msg = malhdpin collection = MHD src_status = malhd srcname = "MyAnimeList" else: data = lcdata pin = lcpin pin_msg = lchdpin collection = HD src_status = lchd srcname = "LiveChart" if re.match(r"^(mal|lc)hd$", qry): if data: await collection.find_one_and_delete(data) src_status = f"{srcname}: OFF" pin_msg = f"Auto Pin: OFF" else: await collection.insert_one({"_id": gid}) src_status = f"{srcname}: ON" pin_msg = f"Auto Pin: OFF" if re.match(r"^(mal|lc)hdpin$", qry): if data: if pin: switch = "ON" if pin == "OFF" else "OFF" await collection.find_one_and_update( data, {"$set": {"pin": switch, "unpin": None}}, upsert=True ) pin_msg = f"Auto Pin: {switch}" else: await collection.find_one_and_update( data, {"$set": {"pin": "ON"}}, upsert=True ) pin_msg = f"Auto Pin: ON" else: await cq.answer(f"Please enable {srcname} first!!!", show_alert=True) if "mal" in qry: malhdpin = pin_msg malhd = src_status else: lchdpin = pin_msg lchd = src_status btn = InlineKeyboardMarkup( [ [InlineKeyboardButton(text=lchd, callback_data=f"headlines_lchd_{gid}")], [ InlineKeyboardButton( text=lchdpin, callback_data=f"headlines_lchdpin_{gid}" ), InlineKeyboardButton( text="Auto Unpin (LC)", callback_data=f"anpin_call_lc_{gid}" ), ], [InlineKeyboardButton(text=malhd, callback_data=f"headlines_malhd_{gid}")], [ InlineKeyboardButton( text=malhdpin, callback_data=f"headlines_malhdpin_{gid}" ), InlineKeyboardButton( text="Auto Unpin (MAL)", callback_data=f"anpin_call_mal_{gid}" ), ], [InlineKeyboardButton(text="BACK", callback_data=f"settogl_call_{gid}")], ] ) await cq.edit_message_text(headlines_text, reply_markup=btn) await cq.answer() TIMES = { "1 day": 86400, "5 days": 432000, "1 week": 604800, "2 week": 1209600, "1 month": 2592000, "New Feed": 0, "OFF": None, } @app.on_callback_query(filters.regex(pattern=r"anpin_(.*)")) async def auto_unpin(client: Client, cq: CallbackQuery): cus = cq.from_user.id qry = cq.data.split("_")[1] src = cq.data.split("_")[2] gid = int(cq.data.split("_")[3]) try: k = (await client.get_chat_member(gid, cus)).status except UserNotParticipant: await cq.answer() return if cus not in BOT_OWNER and k == MEMBER: await cq.answer( "You don't have enough permissions to change this!!!", show_alert=True ) return cancel = False if src == "lc": srcname = "LiveChart" collection = HD else: srcname = "MyAnimeList" collection = MHD data = await collection.find_one({"_id": gid}) if data: try: data["pin"] try: unpin = data["unpin"] except KeyError: unpin = None except KeyError: cancel = True else: cancel = True if cancel: return await cq.answer( f"Please enable {srcname} and Auto Pin option for them!!!", show_alert=True ) setting = None if qry == "call": pass elif qry == "None": setting = {"unpin": None} elif qry.isdigit(): if int(qry) == 0: unpin = int(qry) setting = {"unpin": 0} else: now = round(time.time(), -2) unpin = int(qry) setting = {"unpin": int(qry), "next_unpin": int(qry) + int(now)} if setting: await collection.find_one_and_update(data, {"$set": setting}) btn = [] row = [] count = 0 for i in TIMES.keys(): count = count + 1 row.append( InlineKeyboardButton(i, callback_data=f"unpin_{TIMES[i]}_{src}_{gid}") ) if count == 3: btn.append(row) count = 0 row = [] if len(row) != 0: btn.append(row) btn.append([InlineKeyboardButton("BACK", callback_data=f"headlines_call_{gid}")]) if type(unpin) is int: if unpin == 0: unpindata = "after Next Feed" else: unpindata = "after " + list(TIMES.keys())[list(TIMES.values()).index(unpin)] else: unpindata = "OFF" await cq.edit_message_text( f"Auto Unpin options for {srcname}\nCurrently set to: {unpindata}", reply_markup=InlineKeyboardMarkup(btn), ) await cq.answer() BULLETS = ["➤", "•", "⚬", "▲", "▸", "△", "⋟", "»", "None"] @app.on_callback_query(filters.regex(pattern=r"cui_(.*)")) async def change_ui_btn(client: Client, cq: CallbackQuery): cus = cq.from_user.id qry = cq.data.split("_")[1] gid = cq.data.split("_")[2] try: k = (await client.get_chat_member(gid, cus)).status except UserNotParticipant: await cq.answer() return if cus not in BOT_OWNER and k == MEMBER: await cq.answer( "You don't have enough permissions to change this!!!", show_alert=True ) return await cq.answer() row, btn = [], [] for i in BULLETS: row.append(InlineKeyboardButton(text=i, callback_data=f"cui_{i}_{gid}")) if len(row) == 3: btn.append(row) row = [] btn.append(row) btn.append( [ InlineKeyboardButton(text="CAPS", callback_data=f"cui_Caps_{gid}"), InlineKeyboardButton(text="UPPER", callback_data=f"cui_UPPER_{gid}"), ] ) btn.append([InlineKeyboardButton(text="BACK", callback_data=f"settogl_call_{gid}")]) if qry in ["Caps", "UPPER"]: if await GUI.find_one({"_id": gid}): await GUI.update_one({"_id": gid}, {"$set": {"cs": qry}}) else: await GUI.insert_one({"_id": gid, "bl": "➤", "cs": qry}) elif qry != "call": bullet = qry if qry == "None": bullet = None if await GUI.find_one({"_id": gid}): await GUI.update_one({"_id": gid}, {"$set": {"bl": bullet}}) else: await GUI.insert_one({"_id": gid, "bl": bullet, "cs": "UPPER"}) bl = "➤" cs = "UPPER" if await GUI.find_one({"_id": gid}): data = await GUI.find_one({"_id": gid}) bl = data["bl"] cs = data["cs"] text = f"""Selected bullet in this group: {bl} Selected text case in this group: {cs}""" await cq.edit_message_text(text, reply_markup=InlineKeyboardMarkup(btn)) ## For accepting commands from edited messages @app.on_edited_message( filters.command(["anime", f"anime{BOT_USERNAME}"], prefixes=PREFIX_HANDLER) ) async def anime_edit_cmd(client: app, message: Message): await anime_cmd(client, message) @app.on_edited_message( filters.command(["manga", f"manga{BOT_USERNAME}"], prefixes=PREFIX_HANDLER) ) async def manga_edit_cmd(client: app, message: Message): await manga_cmd(client, message) @app.on_edited_message( filters.command(["character", f"character{BOT_USERNAME}"], prefixes=PREFIX_HANDLER) ) async def character_edit_cmd(client: app, message: Message): await character_cmd(client, message) @app.on_edited_message( filters.command(["anilist", f"anilist{BOT_USERNAME}"], prefixes=PREFIX_HANDLER) ) async def anilist_edit_cmd(client: app, message: Message): await anilist_cmd(client, message) @app.on_edited_message( filters.command(["top", f"top{BOT_USERNAME}"], prefixes=PREFIX_HANDLER) ) async def top_edit_cmd(client: app, message: Message): await top_tags_cmd(client, message) @app.on_edited_message( filters.command(["airing", f"airing{BOT_USERNAME}"], prefixes=PREFIX_HANDLER) ) async def airing_edit_cmd(client: app, message: Message): await airing_cmd(client, message) @app.on_edited_message( ~filters.private & filters.command( ["anisettings", f"anisettings{BOT_USERNAME}"], prefixes=PREFIX_HANDLER ) ) async def settings_edit_cmd(client: app, message: Message): await settings_cmd(client, message) @app.on_edited_message( filters.command(["browse", f"browse{BOT_USERNAME}"], prefixes=PREFIX_HANDLER) ) async def browse_edit_cmd(client: app, message: Message): await browse_cmd(client, message) @app.on_edited_message( filters.command( ["gettags", f"gettags{BOT_USERNAME}", "getgenres", f"getgenres{BOT_USERNAME}"], prefixes=PREFIX_HANDLER, ) ) async def tags_genres_edit_cmd(client: app, message: Message): await list_tags_genres_cmd(client, message) @app.on_message( filters.command(["studio", f"studio{BOT_USERNAME}"], prefixes=PREFIX_HANDLER) ) async def studio_edit_cmd(client: Client, message: Message): await studio_cmd(client, message) @app.on_message( filters.command(["schedule", f"schedule{BOT_USERNAME}"], prefixes=PREFIX_HANDLER) ) @control_user async def get_schuled(client: Client, message: Message, mdata: dict): """Get List of Scheduled Anime""" gid = mdata["chat"]["id"] find_gc = await DC.find_one({"_id": gid}) if find_gc is not None and "schedule" in find_gc["cmd_list"].split(): return x = await client.send_message(gid, "Fetching Scheduled Animes") try: user = mdata["from_user"]["id"] except KeyError: user = mdata["sender_chat"]["id"] msg = await get_scheduled() buttons = get_btns("SCHEDULED", result=[msg[1]], user=user) await x.edit_text(msg[0], reply_markup=buttons) @app.on_callback_query(filters.regex(pattern=r"sched_(.*)")) @check_user async def ns_(client: app, cq: CallbackQuery, cdata: dict): kek, day, user = cdata["data"].split("_") msg = await get_scheduled(int(day)) buttons = get_btns("SCHEDULED", result=[int(day)], user=user) await cq.edit_message_text(msg[0], reply_markup=buttons) @app.on_edited_message( filters.command(["schedule", f"schedule{BOT_USERNAME}"], prefixes=PREFIX_HANDLER) ) async def get_schuled_edit(client: Client, message: Message): await get_schuled(client, message) @app.on_message( filters.command(["watch", f"watch{BOT_USERNAME}"], prefixes=PREFIX_HANDLER) ) @control_user async def get_watch_order(client: Client, message: Message, mdata: dict): """Get List of Scheduled Anime""" gid = mdata["chat"]["id"] find_gc = await DC.find_one({"_id": gid}) if find_gc is not None and "watch" in find_gc["cmd_list"].split(): return x = message.text.split(" ", 1) if len(x) == 1: await message.reply_text("Nothing given to search for!!!") return try: user = mdata["from_user"]["id"] except KeyError: user = mdata["sender_chat"]["id"] data = get_wols(x[1]) msg = f"Found related animes for the query {x[1]}" buttons = [] if data == []: await client.send_message(gid, "No results found!!!") return for i in data: buttons.append( [ InlineKeyboardButton( str(i[1]), callback_data=f"watch_{i[0]}_{x[1]}_0_{user}" ) ] ) await client.send_message(gid, msg, reply_markup=InlineKeyboardMarkup(buttons)) @app.on_callback_query(filters.regex(pattern=r"watch_(.*)")) @check_user async def watch_(client: app, cq: CallbackQuery, cdata: dict): kek, id_, qry, req, user = cdata["data"].split("_") msg, total = get_wo(int(id_), int(req)) totalpg, lol = divmod(total, 50) button = [] if lol != 0: totalpg + 1 if total > 50: if int(req) == 0: button.append( [ InlineKeyboardButton( text="NEXT", callback_data=f"{kek}_{id_}_{qry}_{int(req)+1}_{user}", ) ] ) elif int(req) == totalpg: button.append( [ InlineKeyboardButton( text="PREV", callback_data=f"{kek}_{id_}_{qry}_{int(req)-1}_{user}", ) ] ) else: button.append( [ InlineKeyboardButton( text="PREV", callback_data=f"{kek}_{id_}_{qry}_{int(req)-1}_{user}", ), InlineKeyboardButton( text="NEXT", callback_data=f"{kek}_{id_}_{qry}_{int(req)+1}_{user}", ), ] ) button.append([InlineKeyboardButton("Back", callback_data=f"wol_{qry}_{user}")]) await cq.edit_message_text(msg, reply_markup=InlineKeyboardMarkup(button)) @app.on_callback_query(filters.regex(pattern=r"wol_(.*)")) @check_user async def wls(client: app, cq: CallbackQuery, cdata: dict): kek, qry, user = cdata["data"].split("_") data = get_wols(qry) msg = f"Found related animes for the query {qry}" buttons = [] for i in data: buttons.append( [ InlineKeyboardButton( str(i[1]), callback_data=f"watch_{i[0]}_{qry}_0_{user}" ) ] ) await cq.edit_message_text(msg, reply_markup=InlineKeyboardMarkup(buttons)) @app.on_edited_message( filters.command(["watch", f"watch{BOT_USERNAME}"], prefixes=PREFIX_HANDLER) ) async def get_watch_order_edit(client: Client, message: Message): await get_watch_order(client, message) @app.on_message( filters.command(["fillers", f"fillers{BOT_USERNAME}"], prefixes=PREFIX_HANDLER) ) @control_user async def fillers_cmd(client: app, message: Message, mdata: dict): find_gc = await DC.find_one({"_id": mdata["chat"]["id"]}) try: user = mdata["from_user"]["id"] except KeyError: user = mdata["sender_chat"]["id"] if find_gc is not None and "watch" in find_gc["cmd_list"].split(): return qry = mdata["text"].split(" ", 1) if len(qry) == 1: return await message.reply_text( """Give some anime name to search fillers for example: /fillers Detective Conan""" ) k = search_filler(qry[1]) if k == {}: await message.reply_text("No fillers found for the given anime...") return button = [] list_ = list(k.keys()) if len(list_) == 1: result = parse_filler(k.get(list_[0])) msg = "" msg += f"Fillers for anime `{list_[0]}`\n\nManga Canon episodes:\n" msg += str(result.get("total_ep")) msg += "\n\nMixed/Canon fillers:\n" msg += str(result.get("mixed_ep")) msg += "\n\nFillers:\n" msg += str(result.get("filler_ep")) if result.get("ac_ep") is not None: msg += "\n\nAnime Canon episodes:\n" msg += str(result.get("ac_ep")) await message.reply_text(msg) return for i in list_: fl_js = rand_key() FILLERS[fl_js] = [k.get(i), i] button.append([InlineKeyboardButton(i, callback_data=f"fill_{fl_js}_{user}")]) await message.reply_text( "Pick anime you want to see fillers list for:", reply_markup=InlineKeyboardMarkup(button), ) @app.on_callback_query(filters.regex(pattern=r"fill_(.*)")) @check_user async def filler_btn(client: app, cq: CallbackQuery, cdata: dict): kek, req, user = cdata["data"].split("_") result = parse_filler((FILLERS.get(req))[0]) msg = "" msg += f"**Fillers for anime** `{(FILLERS.get(req))[1]}`" msg += "\n\n**Manga Canon episodes:**\n" msg += str(result.get("total_ep")) msg += "\n\n**Mixed/Canon fillers:**\n" msg += str(result.get("mixed_ep")) msg += "\n\n**Fillers:**\n" msg += str(result.get("filler_ep")) if result.get("ac_ep") is not None: msg += "\n\n**Anime Canon episodes:**\n" msg += str(result.get("ac_ep")) await cq.edit_message_text(msg) @app.on_message( filters.command(["fillers", f"fillers{BOT_USERNAME}"], prefixes=PREFIX_HANDLER) ) async def fillers_cmd(client: app, message: Message): await fillers_cmd(client, message) @app.on_message(filters.command("animequotes")) async def animequotes(client, message): name = ( message.reply_to_message.from_user.first_name if message.reply_to_message else message.from_user.first_name ) keyboard = [[InlineKeyboardButton(text="CHANGE", callback_data="changek_quote")]] await message.reply_photo( photo=random.choice(QUOTES_IMG), reply_markup=InlineKeyboardMarkup(keyboard), ) @app.on_callback_query(filters.regex("changek_quote")) async def changek_quote(client, callback_query): keyboard = [[InlineKeyboardButton(text="CHANGE", callback_data="changek_quote")]] await callback_query.edit_message_media( media=InputMediaPhoto(media=random.choice(QUOTES_IMG)), reply_markup=InlineKeyboardMarkup(keyboard), ) QUOTES_IMG = [ "https://i.imgur.com/Iub4RYj.jpg", "https://i.imgur.com/uvNMdIl.jpg", "https://i.imgur.com/YOBOntg.jpg", "https://i.imgur.com/fFpO2ZQ.jpg", "https://i.imgur.com/f0xZceK.jpg", "https://i.imgur.com/RlVcCip.jpg", "https://i.imgur.com/CjpqLRF.jpg", "https://i.imgur.com/8BHZDk6.jpg", "https://i.imgur.com/8bHeMgy.jpg", "https://i.imgur.com/5K3lMvr.jpg", "https://i.imgur.com/NTzw4RN.jpg", "https://i.imgur.com/wJxryAn.jpg", "https://i.imgur.com/9L0DWzC.jpg", "https://i.imgur.com/sBe8TTs.jpg", "https://i.imgur.com/1Au8gdf.jpg", "https://i.imgur.com/28hFQeU.jpg", "https://i.imgur.com/Qvc03JY.jpg", "https://i.imgur.com/gSX6Xlf.jpg", "https://i.imgur.com/iP26Hwa.jpg", "https://i.imgur.com/uSsJoX8.jpg", "https://i.imgur.com/OvX3oHB.jpg", "https://i.imgur.com/JMWuksm.jpg", "https://i.imgur.com/lhM3fib.jpg", "https://i.imgur.com/64IYKkw.jpg", "https://i.imgur.com/nMbyA3J.jpg", "https://i.imgur.com/7KFQhY3.jpg", "https://i.imgur.com/mlKb7zt.jpg", "https://i.imgur.com/JCQGJVw.jpg", "https://i.imgur.com/hSFYDEz.jpg", "https://i.imgur.com/PQRjAgl.jpg", "https://i.imgur.com/ot9624U.jpg", "https://i.imgur.com/iXmqN9y.jpg", "https://i.imgur.com/RhNBeGr.jpg", "https://i.imgur.com/tcMVNa8.jpg", "https://i.imgur.com/LrVg810.jpg", "https://i.imgur.com/TcWfQlz.jpg", "https://i.imgur.com/muAUdvJ.jpg", "https://i.imgur.com/AtC7ZRV.jpg", "https://i.imgur.com/sCObQCQ.jpg", "https://i.imgur.com/AJFDI1r.jpg", "https://i.imgur.com/TCgmRrH.jpg", "https://i.imgur.com/LMdmhJU.jpg", "https://i.imgur.com/eyyax0N.jpg", "https://i.imgur.com/YtYxV66.jpg", "https://i.imgur.com/292w4ye.jpg", "https://i.imgur.com/6Fm1vdw.jpg", "https://i.imgur.com/2vnBOZd.jpg", "https://i.imgur.com/j5hI9Eb.jpg", "https://i.imgur.com/cAv7pJB.jpg", "https://i.imgur.com/jvI7Vil.jpg", "https://i.imgur.com/fANpjsg.jpg", "https://i.imgur.com/5o1SJyo.jpg", "https://i.imgur.com/dSVxmh8.jpg", "https://i.imgur.com/02dXlAD.jpg", "https://i.imgur.com/htvIoGY.jpg", "https://i.imgur.com/hy6BXOj.jpg", "https://i.imgur.com/OuwzNYu.jpg", "https://i.imgur.com/L8vwvc2.jpg", "https://i.imgur.com/3VMVF9y.jpg", "https://i.imgur.com/yzjq2n2.jpg", "https://i.imgur.com/0qK7TAN.jpg", "https://i.imgur.com/zvcxSOX.jpg", "https://i.imgur.com/FO7bApW.jpg", "https://i.imgur.com/KK06gwg.jpg", "https://i.imgur.com/6lG4tsO.jpg", ] # <================================================= HELP ======================================================> __help__ = """ ⛩ *Anime:* ➠ *Dazai provides you the best anime-based commands including anime news and much more!* ➠ *Commands:* » /anime: fetches info on single anime (includes buttons to look up for prequels and sequels) » /character: fetches info on multiple possible characters related to query » /manga: fetches info on multiple possible mangas related to query » /airing: fetches info on airing data for anime » /studio: fetches info on multiple possible studios related to query » /schedule: fetches scheduled animes » /browse: get popular, trending or upcoming animes ➠ /animequotes: get random anime quotes » /anisettings: to toggle NSFW lock and airing notifications and other settings in groups (anime news) » /top: to retrieve top animes for a genre or tag » /watch: fetches watch order for anime series » /fillers: to get a list of anime fillers » /gettags: get a list of available tags » /getgenres - Get list of available Genres """ __mod_name__ = "ANIME" # <================================================== END =====================================================>