• `/git <user>/<repo>`: will fetch the most recent release from that repo. • `/git <user>/<repo> <number>`: will fetch releases in past. • `/fetch <reponame> or &reponame`: same as `/git`, but you can use a saved repo shortcut • `/listrepo`: lists all repo shortcuts in chat • `/gitver`: returns the current API version • `/changelog <reponame>`: gets the changelog of a saved repo shortcut *Admin only:* • `/saverepo <name> <user>/<repo> <number (optional)>`: saves a repo value as shortcut • `/delrepo <name>`: deletes a repo shortcut """ __mod_name__ = "GitHub" RELEASE_HANDLER = DisableAbleCommandHandler("git", getRelease, pass_args=True, admin_ok=True) FETCH_HANDLER = DisableAbleCommandHandler("fetch", cmdFetch, pass_args=True, admin_ok=True) SAVEREPO_HANDLER = CommandHandler("saverepo", saveRepo, pass_args=True) DELREPO_HANDLER = CommandHandler("delrepo", delRepo, pass_args=True) LISTREPO_HANDLER = DisableAbleCommandHandler("listrepo", listRepo, admin_ok=True) VERCHECKER_HANDLER = DisableAbleCommandHandler("gitver", getVer, admin_ok=True) CHANGELOG_HANDLER = DisableAbleCommandHandler("changelog", changelog, pass_args=True, admin_ok=True)
• `/shrug`*:* get shrug XD • `/table`*:* get flip/unflip :v • `/decide`*:* Randomly answers yes/no/maybe • `/toss`*:* Tosses A coin • `/bluetext`*:* check urself :V • `/roll`*:* Roll a dice • `/rlg`*:* Join ears,nose,mouth and create an emo ;-; • `/shout <keyword>`*:* write anything you want to give loud shout • `/weebify <text>`*:* returns a weebified text • `/sanitize`*:* always use this before /pat or any contact • `/pat`*:* pats a user, or get patted • `/8ball`*:* predicts using 8ball method • `/plet`*:* text get funny emojify """ SANITIZE_HANDLER = DisableAbleCommandHandler("sanitize", sanitize) RUNS_HANDLER = DisableAbleCommandHandler("runs", runs) SLAP_HANDLER = DisableAbleCommandHandler("slap", slap) PAT_HANDLER = DisableAbleCommandHandler("pat", pat) ROLL_HANDLER = DisableAbleCommandHandler("roll", roll) TOSS_HANDLER = DisableAbleCommandHandler("toss", toss) SHRUG_HANDLER = DisableAbleCommandHandler("shrug", shrug) BLUETEXT_HANDLER = DisableAbleCommandHandler("bluetext", bluetext) RLG_HANDLER = DisableAbleCommandHandler("rlg", rlg) DECIDE_HANDLER = DisableAbleCommandHandler("decide", decide) EIGHTBALL_HANDLER = DisableAbleCommandHandler("8ball", eightball) TABLE_HANDLER = DisableAbleCommandHandler("table", table) SHOUT_HANDLER = DisableAbleCommandHandler("shout", shout) WEEBIFY_HANDLER = DisableAbleCommandHandler("weebify", weebify) dispatcher.add_handler(WEEBIFY_HANDLER)
if message.reply_to_message: reply = message.reply_to_message.text if args: reply = ' '.join(args).lower() current_time = datetime.strftime(datetime.now(), "%d.%m.%Y %H:%M:%S") filename = datetime.now().strftime("%d%m%y-%H%M%S%f") update.message.chat.send_action(ChatAction.RECORD_AUDIO) lang = "ml" tts = gTTS(reply, lang) tts.save("k.mp3") with open("k.mp3", "rb") as f: linelist = list(f) linecount = len(linelist) if linecount == 1: update.message.chat.send_action(ChatAction.RECORD_AUDIO) lang = "en" tts = gTTS(reply, lang) tts.save("k.mp3") with open("k.mp3", "rb") as speech: update.message.reply_voice(speech, quote=False) os.remove("k.mp3") TTS_HANDLER = DisableAbleCommandHandler("tts", tts, pass_args=True) dispatcher.add_handler(TTS_HANDLER) __handlers__ = [TTS_HANDLER]
result = generate_time(query_timezone, ["countryCode"]) else: result = generate_time(query_timezone, ["zoneName", "countryName"]) if not result: send_message.edit_text( f'Timezone info not available for <b>{query}</b>\n' '<b>All Timezones:</b> <a href="https://en.wikipedia.org/wiki/List_of_tz_database_time_zones">List here</a>', parse_mode=ParseMode.HTML, disable_web_page_preview=True) return send_message.edit_text( result, parse_mode=ParseMode.HTML, disable_web_page_preview=True) __help__ = """ • `/time <query>`*:* Gives information about a timezone. *Available queries:* Country Code/Country Name/Timezone Name • 🕐 [Timezones list](https://en.wikipedia.org/wiki/List_of_tz_database_time_zones) """ TIME_HANDLER = DisableAbleCommandHandler("time", gettime) dispatcher.add_handler(TIME_HANDLER) __mod_name__ = "Time" __command_list__ = ["time"] __handlers__ = [TIME_HANDLER]
True, 'key': 'FFmpegMetadata', 'prefer_ffmpeg': True, 'geo_bypass': True, 'nocheckcertificate': True, 'postprocessors': [{ 'key': 'FFmpegVideoConvertor', 'preferedformat': 'mp4' }], 'outtmpl': '%(id)s.mp4', 'logtostderr': False, 'quiet': True } await process(v_url, "video", opts) SONG_HANDLER = DisableAbleCommandHandler('song', song) VIDEO_HANDLER = DisableAbleCommandHandler('video', video) dispatcher.add_handler(SONG_HANDLER) dispatcher.add_handler(VIDEO_HANDLER) __handlers__ = [SONG_HANDLER, VIDEO_HANDLER]
"<b>Service uptime:</b> <code>{}</code>".format( telegram_ping, uptime), parse_mode=ParseMode.HTML) @run_async @sudo_plus def pingall(update: Update, context: CallbackContext): to_ping = ["Kaizoku", "Kayo", "Telegram", "Jikan"] pinged_list = ping_func(to_ping) pinged_list.insert(2, '') uptime = get_readable_time((time.time() - StartTime)) reply_msg = "⏱Ping results are:\n" reply_msg += "\n".join(pinged_list) reply_msg += '\n<b>Service uptime:</b> <code>{}</code>'.format(uptime) update.effective_message.reply_text(reply_msg, parse_mode=ParseMode.HTML, disable_web_page_preview=True) PING_HANDLER = DisableAbleCommandHandler("ping", ping) PINGALL_HANDLER = DisableAbleCommandHandler("pingall", pingall) dispatcher.add_handler(PING_HANDLER) dispatcher.add_handler(PINGALL_HANDLER) __command_list__ = ["ping", "pingall"] __handlers__ = [PING_HANDLER, PINGALL_HANDLER]
• `/paste`*:* saves replied content to `nekobin.com` and replies with a url\n *React:* • `/react`*:* reacts with a random reaction\n *Urban Dictonary:* • `/ud <word>`*:* type the word or expression you want to search use\n *Wikipedia:* • `/wiki <query>`*:* wikipedia your query\n *Wallpapers:* • `/wall <query>`*:* get a wallpaper from wall.alphacoders.com\n *Currency converter:* • `/cash`*:* currency converter Example: `/cash 1 USD INR` _OR_ `/cash 1 usd inr` Output: `1.0 USD = 75.505 INR` """ ECHO_HANDLER = DisableAbleCommandHandler("echo", echo, filters=Filters.group) MD_HELP_HANDLER = CommandHandler("markdownhelp", markdown_help) dispatcher.add_handler(ECHO_HANDLER) dispatcher.add_handler(MD_HELP_HANDLER) __mod_name__ = "Extras" __command_list__ = ["id", "echo", "covid", "weather", "quotly"] __handlers__ = [ ECHO_HANDLER, MD_HELP_HANDLER, ]
Reply 3` • `/clear <notename>`*:* clear note with this name • `/removeallnotes`*:* removes all notes from the group *Note:* Note names are case-insensitive, and they are automatically converted to lowercase before getting saved. """ __mod_name__ = "Notes" GET_HANDLER = CommandHandler("get", cmd_get) HASH_GET_HANDLER = MessageHandler(Filters.regex(r"^#[^\s]+"), hash_get) SLASH_GET_HANDLER = MessageHandler(Filters.regex(r"^/\d+$"), slash_get) SAVE_HANDLER = CommandHandler("save", save) DELETE_HANDLER = CommandHandler("clear", clear) LIST_HANDLER = DisableAbleCommandHandler(["notes", "saved"], list_notes, admin_ok=True) CLEARALL = DisableAbleCommandHandler("removeallnotes", clearall) CLEARALL_BTN = CallbackQueryHandler(clearall_btn, pattern=r"notes_.*") dispatcher.add_handler(GET_HANDLER) dispatcher.add_handler(SAVE_HANDLER) dispatcher.add_handler(LIST_HANDLER) dispatcher.add_handler(DELETE_HANDLER) dispatcher.add_handler(HASH_GET_HANDLER) dispatcher.add_handler(SLASH_GET_HANDLER) dispatcher.add_handler(CLEARALL) dispatcher.add_handler(CLEARALL_BTN)
Examples: `/setme I am a wolf.` `/me @username(defaults to yours if no user specified)` *Information others add on you:* • `/bio`*:* will get your or another user's bio. This cannot be set by yourself. • `/setbio <text>`*:* while replying, will save another user's bio Examples: `/bio @username(defaults to yours if not specified).` `/setbio This user is a wolf` (reply to the user) *Overall Information about you:* • `/info`*:* get information about a user. """ SET_BIO_HANDLER = DisableAbleCommandHandler("setbio", set_about_bio) GET_BIO_HANDLER = DisableAbleCommandHandler("bio", about_bio) STATS_HANDLER = CommandHandler("stats", stats) ID_HANDLER = DisableAbleCommandHandler("id", get_id) GIFID_HANDLER = DisableAbleCommandHandler("gifid", gifid) INFO_HANDLER = DisableAbleCommandHandler(("info", "book"), info) SET_ABOUT_HANDLER = DisableAbleCommandHandler("setme", set_about_me) GET_ABOUT_HANDLER = DisableAbleCommandHandler("me", about_me) dispatcher.add_handler(STATS_HANDLER) dispatcher.add_handler(ID_HANDLER) dispatcher.add_handler(GIFID_HANDLER) dispatcher.add_handler(INFO_HANDLER) dispatcher.add_handler(SET_BIO_HANDLER)
import requests from NadiasBot import dispatcher from NadiasBot.modules.disable import DisableAbleCommandHandler from telegram import ParseMode, Update from telegram.ext import CallbackContext, run_async @run_async def ud(update: Update, context: CallbackContext): message = update.effective_message text = message.text[len('/ud '):] results = requests.get( f'https://api.urbandictionary.com/v0/define?term={text}').json() try: reply_text = f'*{text}*\n\n{results["list"][0]["definition"]}\n\n_{results["list"][0]["example"]}_' except: reply_text = "No results found." message.reply_text(reply_text, parse_mode=ParseMode.MARKDOWN) UD_HANDLER = DisableAbleCommandHandler(["ud"], ud) dispatcher.add_handler(UD_HANDLER) __command_list__ = ["ud"] __handlers__ = [UD_HANDLER]
x = 0 y = 896 image = Image.new('RGBA', [x, y], (0, 0, 0)) for character in msg: value = thonkifydict.get(character) addedimg = Image.new('RGBA', [x + value.size[0] + tracking.size[0], y], (0, 0, 0)) addedimg.paste(image, [0, 0]) addedimg.paste(tracking, [x, 0]) addedimg.paste(value, [x + tracking.size[0], 0]) image = addedimg x = x + value.size[0] + tracking.size[0] maxsize = 1024, 896 if image.size[0] > maxsize[0]: image.thumbnail(maxsize, Image.ANTIALIAS) # put processed image in a buffer and then upload cause async with BytesIO() as buffer: buffer.name = 'image.png' image.save(buffer, 'PNG') buffer.seek(0) context.bot.send_sticker(chat_id=message.chat_id, sticker=buffer) PLET_HANDLER = DisableAbleCommandHandler("plet", plet) dispatcher.add_handler(PLET_HANDLER) __handlers__ = [ PLET_HANDLER ]
if message.reply_to_message: data = message.reply_to_message.text elif len(args) >= 1: data = message.text.split(None, 1)[1] else: message.reply_text("What am I supposed to do with this?") return key = requests.post('https://nekobin.com/api/documents', json={ "content": data }).json().get('result').get('key') url = f'https://nekobin.com/{key}' reply_text = f'Nekofied to *Nekobin* : {url}' message.reply_text(reply_text, parse_mode=ParseMode.MARKDOWN, disable_web_page_preview=True) PASTE_HANDLER = DisableAbleCommandHandler("paste", paste) dispatcher.add_handler(PASTE_HANDLER) __command_list__ = ["paste"] __handlers__ = [PASTE_HANDLER]
def scam(imgspage, lim): """Parse/Scrape the HTML code for the info we want.""" single = opener.open(imgspage).read() decoded = single.decode('utf-8') if int(lim) > 10: lim = 10 imglinks = [] counter = 0 pattern = r'^,\[\"(.*[.png|.jpg|.jpeg])\",[0-9]+,[0-9]+\]$' oboi = re.findall(pattern, decoded, re.I | re.M) for imglink in oboi: counter += 1 imglinks.append(imglink) if counter >= int(lim): break return imglinks REVERSE_HANDLER = DisableAbleCommandHandler("reverse", reverse, pass_args=True, admin_ok=True) dispatcher.add_handler(REVERSE_HANDLER)
__help__ = """ Blacklists are used to stop certain triggers from being said in a group. Any time the trigger is mentioned, the message will immediately be deleted. A good combo is sometimes to pair this up with warn filters! *NOTE*: Blacklists do not affect group admins. • `/blacklist`*:* View the current blacklisted words. Admin only: • `/addblacklist <triggers>`*:* Add a trigger to the blacklist. Each line is considered one trigger, so using different lines will allow you to add multiple triggers. • `/unblacklist <triggers>`*:* Remove triggers from the blacklist. Same newline logic applies here, so you can remove multiple triggers at once. • `/blacklistmode <off/del/warn/ban/kick/mute/tban/tmute>`*:* Action to perform when someone sends blacklisted words. """ BLACKLIST_HANDLER = DisableAbleCommandHandler( "blacklist", blacklist, pass_args=True, admin_ok=True) ADD_BLACKLIST_HANDLER = CommandHandler("addblacklist", add_blacklist) UNBLACKLIST_HANDLER = CommandHandler("unblacklist", unblacklist) BLACKLISTMODE_HANDLER = CommandHandler( "blacklistmode", blacklist_mode, pass_args=True) BLACKLIST_DEL_HANDLER = MessageHandler( (Filters.text | Filters.command | Filters.sticker | Filters.photo) & Filters.group, del_blacklist, allow_edit=True, ) dispatcher.add_handler(BLACKLIST_HANDLER) dispatcher.add_handler(ADD_BLACKLIST_HANDLER) dispatcher.add_handler(UNBLACKLIST_HANDLER) dispatcher.add_handler(BLACKLISTMODE_HANDLER)
speed.download() speed.upload() replymsg = 'SpeedTest Results:' if query.data == 'speedtest_image': speedtest_image = speed.results.share() update.effective_message.reply_photo(photo=speedtest_image, caption=replymsg) msg.delete() elif query.data == 'speedtest_text': result = speed.results.dict() replymsg += f"\nDownload: `{convert(result['download'])}Mb/s`\nUpload: `{convert(result['upload'])}Mb/s`\nPing: `{result['ping']}`" update.effective_message.edit_text(replymsg, parse_mode=ParseMode.MARKDOWN) else: query.answer( "You are required to be a developer user to use this command.") SPEED_TEST_HANDLER = DisableAbleCommandHandler("speedtest", speedtestxyz) SPEED_TEST_CALLBACKHANDLER = CallbackQueryHandler(speedtestxyz_callback, pattern='speedtest_.*') dispatcher.add_handler(SPEED_TEST_HANDLER) dispatcher.add_handler(SPEED_TEST_CALLBACKHANDLER) __mod_name__ = "SpeedTest" __command_list__ = ["speedtest"] __handlers__ = [SPEED_TEST_HANDLER, SPEED_TEST_CALLBACKHANDLER]
__help__ = """ Blacklist sticker is used to stop certain stickers. Whenever a sticker is sent, the message will be deleted immediately. *NOTE:* Blacklist stickers do not affect the group admin • `/blsticker`*:* See current blacklisted sticker *Only admin:* • `/addblsticker <sticker link>`*:* Add the sticker trigger to the black list. Can be added via reply sticker • `/unblsticker <sticker link>`*:* Remove triggers from blacklist. The same newline logic applies here, so you can delete multiple triggers at once • `/rmblsticker <sticker link>`*:* Same as above • `/blstickermode <ban/tban/mute/tmute>`*:* sets up a default action on what to do if users use blacklisted stickers Note: • `<sticker link>` can be `https://t.me/addstickers/<sticker>` or just `<sticker>` or reply to the sticker message """ __mod_name__ = "Stickers Blacklist" BLACKLIST_STICKER_HANDLER = DisableAbleCommandHandler( "blsticker", blackliststicker, admin_ok=True) ADDBLACKLIST_STICKER_HANDLER = DisableAbleCommandHandler( "addblsticker", add_blackliststicker) UNBLACKLIST_STICKER_HANDLER = CommandHandler(["unblsticker", "rmblsticker"], unblackliststicker) BLACKLISTMODE_HANDLER = CommandHandler("blstickermode", blacklist_mode) BLACKLIST_STICKER_DEL_HANDLER = MessageHandler(Filters.sticker & Filters.group, del_blackliststicker) dispatcher.add_handler(BLACKLIST_STICKER_HANDLER) dispatcher.add_handler(ADDBLACKLIST_STICKER_HANDLER) dispatcher.add_handler(UNBLACKLIST_STICKER_HANDLER) dispatcher.add_handler(BLACKLISTMODE_HANDLER) dispatcher.add_handler(BLACKLIST_STICKER_DEL_HANDLER)
json_rep = r.get( f"https://wall.alphacoders.com/api2.0/get.php?auth={WALL_API}&method=search&term={term}" ).json() if not json_rep.get("success"): msg.reply_text(f"An error occurred! Report this @{SUPPORT_CHAT}") else: wallpapers = json_rep.get("wallpapers") if not wallpapers: msg.reply_text("No results found! Refine your search.") return else: index = randint(0, len(wallpapers) - 1) # Choose random index wallpaper = wallpapers[index] wallpaper = wallpaper.get("url_image") wallpaper = wallpaper.replace("\\", "") bot.send_photo(chat_id, photo=wallpaper, caption='Preview', reply_to_message_id=msg_id, timeout=60) bot.send_document(chat_id, document=wallpaper, filename='wallpaper', caption=caption, reply_to_message_id=msg_id, timeout=60) WALLPAPER_HANDLER = DisableAbleCommandHandler("wall", wall) dispatcher.add_handler(WALLPAPER_HANDLER)
return if success: msg.reply_text( "Sticker pack successfully created. Get it [here](t.me/addstickers/%s)" % packname, parse_mode=ParseMode.MARKDOWN, ) else: msg.reply_text( "Failed to create sticker pack. Possibly due to blek mejik.") __help__ = """ • `/stickerid`*:* reply to a sticker to me to tell you its file ID. • `/getsticker`*:* reply to a sticker to me to upload its raw PNG file. • `/kang`*:* reply to a sticker to add it to your pack. • `/stickers`*:* Find stickers for given term on combot sticker catalogue """ __mod_name__ = "Stickers" STICKERID_HANDLER = DisableAbleCommandHandler("stickerid", stickerid) GETSTICKER_HANDLER = DisableAbleCommandHandler("getsticker", getsticker) KANG_HANDLER = DisableAbleCommandHandler("kang", kang, admin_ok=True) STICKERS_HANDLER = DisableAbleCommandHandler("stickers", cb_sticker) dispatcher.add_handler(STICKERS_HANDLER) dispatcher.add_handler(STICKERID_HANDLER) dispatcher.add_handler(GETSTICKER_HANDLER) dispatcher.add_handler(KANG_HANDLER)
__help__ = """ • `/admins`*:* list of admins in the chat *Admins only:* • `/pin`*:* silently pins the message replied to - add `'loud'` or `'notify'` to give notifs to users • `/unpin`*:* unpins the currently pinned message • `/invitelink`*:* gets invitelink • `/link`*:* same as invitelink • `/promote`*:* promotes the user replied to • `/demote`*:* demotes the user replied to • `/title <title here>`*:* sets a custom title for an admin that the bot promoted • `/admincache`*:* force refresh the admins list • `/zombies`*:* scan and clean zombies """ ADMINLIST_HANDLER = DisableAbleCommandHandler("admins", adminlist) PIN_HANDLER = CommandHandler("pin", pin, filters=Filters.group) UNPIN_HANDLER = CommandHandler("unpin", unpin, filters=Filters.group) INVITE_HANDLER = DisableAbleCommandHandler(["invitelink", "link"], invite) PROMOTE_HANDLER = DisableAbleCommandHandler("promote", promote) DEMOTE_HANDLER = DisableAbleCommandHandler("demote", demote) SET_TITLE_HANDLER = CommandHandler("title", set_title) ADMIN_REFRESH_HANDLER = CommandHandler( "admincache", refresh_admin, filters=Filters.group) dispatcher.add_handler(ADMINLIST_HANDLER) dispatcher.add_handler(PIN_HANDLER)
update.effective_message.reply_text(res) else: if int(userc_id) == int(user_id): return res = "{} is afk.\nReason: <code>{}</code>".format( html.escape(fst_name), html.escape(user.reason)) update.effective_message.reply_text(res, parse_mode="html") __help__ = """ • `/afk <reason>`*:* mark yourself as AFK(away from keyboard). • `brb <reason>`*:* same as the afk command - but not a command. When marked as AFK, any mentions will be replied to with a message to say you're not available! """ AFK_HANDLER = DisableAbleCommandHandler("afk", afk) AFK_REGEX_HANDLER = DisableAbleMessageHandler( Filters.regex(r"^(?i)brb(.*)$"), afk, friendly="afk") NO_AFK_HANDLER = MessageHandler(Filters.all & Filters.group, no_longer_afk) AFK_REPLY_HANDLER = MessageHandler(Filters.all & Filters.group, reply_afk) dispatcher.add_handler(AFK_HANDLER, AFK_GROUP) dispatcher.add_handler(AFK_REGEX_HANDLER, AFK_GROUP) dispatcher.add_handler(NO_AFK_HANDLER, AFK_GROUP) dispatcher.add_handler(AFK_REPLY_HANDLER, AFK_REPLY_GROUP) __mod_name__ = "AFK" __command_list__ = ["afk"] __handlers__ = [(AFK_HANDLER, AFK_GROUP), (AFK_REGEX_HANDLER, AFK_GROUP), (NO_AFK_HANDLER, AFK_GROUP), (AFK_REPLY_HANDLER, AFK_REPLY_GROUP)]
except DisambiguationError as e: update.message.reply_text( "Disambiguated pages found! Adjust your query accordingly.\n<i>{}</i>" .format(e), parse_mode=ParseMode.HTML) except PageError as e: update.message.reply_text("<code>{}</code>".format(e), parse_mode=ParseMode.HTML) if res: result = f"<b>{search}</b>\n\n" result += f"<i>{res}</i>\n" result += f"""<a href="https://en.wikipedia.org/wiki/{search.replace(" ", "%20")}">Read more...</a>""" if len(result) > 4000: with open("result.txt", 'w') as f: f.write(f"{result}\n\nUwU OwO OmO UmU") with open("result.txt", 'rb') as f: context.bot.send_document( document=f, filename=f.name, reply_to_message_id=update.message.message_id, chat_id=update.effective_chat.id, parse_mode=ParseMode.HTML) else: update.message.reply_text(result, parse_mode=ParseMode.HTML, disable_web_page_preview=True) WIKI_HANDLER = DisableAbleCommandHandler("wiki", wiki) dispatcher.add_handler(WIKI_HANDLER)
return log __help__ = """ • `/punchme`*:* punchs the user who issued the command • `/kickme`*:* same as punchme *Admins only:* • `/ban <userhandle>`*:* bans a user. (via handle, or reply) • `/tban <userhandle> x(m/h/d)`*:* bans a user for `x` time. (via handle, or reply). `m` = `minutes`, `h` = `hours`, `d` = `days`. • `/unban <userhandle>`*:* unbans a user. (via handle, or reply) • `/punch <userhandle>`*:* Punches a user out of the group, (via handle, or reply) • `/kick <userhandle>`*:* same as punch """ BAN_HANDLER = DisableAbleCommandHandler("ban", ban) TEMPBAN_HANDLER = DisableAbleCommandHandler(["tban"], temp_ban) PUNCH_HANDLER = DisableAbleCommandHandler(["punch", "kick"], punch) UNBAN_HANDLER = DisableAbleCommandHandler("unban", unban) ROAR_HANDLER = DisableAbleCommandHandler("roar", selfunban) PUNCHME_HANDLER = DisableAbleCommandHandler(["punchme", "kickme"], punchme, filters=Filters.group) dispatcher.add_handler(BAN_HANDLER) dispatcher.add_handler(TEMPBAN_HANDLER) dispatcher.add_handler(PUNCH_HANDLER) dispatcher.add_handler(UNBAN_HANDLER) dispatcher.add_handler(ROAR_HANDLER) dispatcher.add_handler(PUNCHME_HANDLER)
Get information about anime, manga or characters from [AniList](anilist.co). *Available commands:* • `/anime <anime>`*:* returns information about the anime. • `/character <character>`*:* returns information about the character. • `/manga <manga>`*:* returns information about the manga. • `/user <user>`*:* returns information about a MyAnimeList user. • `/upcoming`*:* returns a list of new anime in the upcoming seasons. • `/kaizoku <anime>`*:* search an anime on animekaizoku.com • `/kayo <anime>`*:* search an anime on animekayo.com • `/airing <anime>`*:* returns anime airing info. """ ANIME_HANDLER = DisableAbleCommandHandler("anime", anime) AIRING_HANDLER = DisableAbleCommandHandler("airing", airing) CHARACTER_HANDLER = DisableAbleCommandHandler("character", character) MANGA_HANDLER = DisableAbleCommandHandler("manga", manga) USER_HANDLER = DisableAbleCommandHandler("user", user) UPCOMING_HANDLER = DisableAbleCommandHandler("upcoming", upcoming) KAIZOKU_SEARCH_HANDLER = DisableAbleCommandHandler("kaizoku", kaizoku) KAYO_SEARCH_HANDLER = DisableAbleCommandHandler("kayo", kayo) BUTTON_HANDLER = CallbackQueryHandler(button, pattern='anime_.*') dispatcher.add_handler(BUTTON_HANDLER) dispatcher.add_handler(ANIME_HANDLER) dispatcher.add_handler(CHARACTER_HANDLER) dispatcher.add_handler(MANGA_HANDLER) dispatcher.add_handler(AIRING_HANDLER) dispatcher.add_handler(USER_HANDLER)
from NadiasBot import dispatcher from NadiasBot.modules.disable import DisableAbleCommandHandler from telegram import Update from telegram.ext import CallbackContext, run_async @run_async def shout(update: Update, context: CallbackContext): args = context.args text = " ".join(args) result = [] result.append(' '.join([s for s in text])) for pos, symbol in enumerate(text[1:]): result.append(symbol + ' ' + ' ' * pos + symbol) result = list("\n".join(result)) result[0] = text[0] result = "".join(result) msg = "```\n" + result + "```" return update.effective_message.reply_text(msg, parse_mode="MARKDOWN") SHOUT_HANDLER = DisableAbleCommandHandler("shout", shout) dispatcher.add_handler(SHOUT_HANDLER) __command_list__ = ["shout"] __handlers__ = [SHOUT_HANDLER]
• `/locks`*:* The current list of locks in this chat. Locks can be used to restrict a group's users. eg: Locking urls will auto-delete all messages with urls, locking stickers will restrict all \ non-admin users from sending stickers, etc. Locking bots will stop non-admins from adding bots to the chat. *Note:* • Unlocking permission *info* will allow members (non-admins) to change the group information, such as the description or the group name • Unlocking permission *pin* will allow members (non-admins) to pinned a message in a group """ __mod_name__ = "Locks" LOCKTYPES_HANDLER = DisableAbleCommandHandler("locktypes", locktypes) LOCK_HANDLER = CommandHandler("lock", lock, pass_args=True) # , filters=Filters.group) UNLOCK_HANDLER = CommandHandler("unlock", unlock, pass_args=True) # , filters=Filters.group) LOCKED_HANDLER = CommandHandler("locks", list_locks) # , filters=Filters.group) dispatcher.add_handler(LOCK_HANDLER) dispatcher.add_handler(UNLOCK_HANDLER) dispatcher.add_handler(LOCKTYPES_HANDLER) dispatcher.add_handler(LOCKED_HANDLER) dispatcher.add_handler( MessageHandler(Filters.all & Filters.group, del_lockables), PERM_GROUP)
• `/addwarn <keyword> <reply message>`*:* set a warning filter on a certain keyword. If you want your keyword to \ be a sentence, encompass it with quotes, as such: `/addwarn "very angry" This is an angry user`. • `/nowarn <keyword>`*:* stop a warning filter • `/warnlimit <num>`*:* set the warning limit • `/strongwarn <on/yes/off/no>`*:* If set to on, exceeding the warn limit will result in a ban. Else, will just punch. """ __mod_name__ = "Warnings" WARN_HANDLER = CommandHandler("warn", warn_user, filters=Filters.group) RESET_WARN_HANDLER = CommandHandler(["resetwarn", "resetwarns"], reset_warns, filters=Filters.group) CALLBACK_QUERY_HANDLER = CallbackQueryHandler(button, pattern=r"rm_warn") MYWARNS_HANDLER = DisableAbleCommandHandler("warns", warns, filters=Filters.group) ADD_WARN_HANDLER = CommandHandler("addwarn", add_warn_filter, filters=Filters.group) RM_WARN_HANDLER = CommandHandler(["nowarn", "stopwarn"], remove_warn_filter, filters=Filters.group) LIST_WARN_HANDLER = DisableAbleCommandHandler(["warnlist", "warnfilters"], list_warn_filters, filters=Filters.group, admin_ok=True) WARN_FILTER_HANDLER = MessageHandler(CustomFilters.has_text & Filters.group, reply_filter) WARN_LIMIT_HANDLER = CommandHandler("warnlimit", set_warn_limit,
"( ◡‿◡ *)", "(//ω//)", "( ̄▽ ̄*)ゞ", "(„ಡωಡ„)", "(ノ´ з `)ノ", "(♡-_-♡)", "(─‿‿─)♡", "(´ ω `♡)", "(ღ˘⌣˘ღ)", "(´• ω •`) ♡", "╰(*´︶`*)╯♡", "(≧◡≦) ♡", "♡ (˘▽˘>ԅ( ˘⌣˘)", "σ(≧ε≦σ) ♡", "(˘∀˘)/(μ‿μ) ❤", "Σ>―(〃°ω°〃)♡→", "(* ^ ω ^)", "(o^▽^o)", "ヽ(・∀・)ノ", "(o・ω・o)", "(^人^)", "( ´ ω ` )", "(´• ω •`)", "╰(▔∀▔)╯", "(✯◡✯)", "(⌒‿⌒)", "(*°▽°*)", "(´。• ᵕ •。`)", "ヽ(>∀<☆)ノ", "\( ̄▽ ̄)/", "(o˘◡˘o)", "(╯✧▽✧)╯", "( ‾́ ◡ ‾́ )", "(๑˘︶˘๑)", "(´・ᴗ・ ` )", "( ͡° ʖ̯ ͡°)", "( ఠ ͟ʖ ఠ)", "( ಥ ʖ̯ ಥ)", "(≖ ͜ʖ≖)", "ヘ( ̄ω ̄ヘ)", "(ノ≧∀≦)ノ", "└( ̄- ̄└))", "┌(^^)┘", "(^_^♪)", "(〜 ̄△ ̄)〜", "(「• ω •)「", "( ˘ ɜ˘) ♬♪♫", "( o˘◡˘o) ┌iii┐", "♨o(>_<)o♨", "( ・・)つ―{}@{}@{}-", "(*´з`)口゚。゚口(・∀・ )", "( *^^)o∀*∀o(^^* )", "-●●●-c(・・ )", "(ノ≧∀≦)ノ ‥…━━━★", "╰( ͡° ͜ʖ ͡° )つ──☆*:・゚", "(∩ᄑ_ᄑ)⊃━☆゚*・。*・:≡( ε:)" ] @run_async def react(update: Update, context: CallbackContext): message = update.effective_message react = random.choice(reactions) if message.reply_to_message: message.reply_to_message.reply_text(react) else: message.reply_text(react) REACT_HANDLER = DisableAbleCommandHandler("react", react) dispatcher.add_handler(REACT_HANDLER) __command_list__ = ["react"] __handlers__ = [REACT_HANDLER]