- /lock <type>: lock items of a certain type (not available in private) - /unlock <type>: unlock items of a certain type (not available in private) - /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 which haven't been whitelisted, locking stickers will delete all \ stickers, etc. Locking bots will stop non-admins from adding bots to the chat. """ LOCKTYPES_HANDLER = DisableAbleCommandHandler("locktypes", locktypes) LOCK_HANDLER = CommandHandler("lock", lock, pass_args=True) UNLOCK_HANDLER = CommandHandler("unlock", unlock, pass_args=True) LOCKED_HANDLER = CommandHandler("locks", list_locks) LOCKABLE_HANDLER = MessageHandler(Filters.all & Filters.group, del_lockables) RESTRICTION_HANDLER = MessageHandler(Filters.all & Filters.group, rest_handler) dispatcher.add_handler(LOCK_HANDLER) dispatcher.add_handler(UNLOCK_HANDLER) dispatcher.add_handler(LOCKTYPES_HANDLER) dispatcher.add_handler(LOCKED_HANDLER) dispatcher.add_handler(LOCKABLE_HANDLER, PERM_GROUP) dispatcher.add_handler(RESTRICTION_HANDLER, REST_GROUP) __mod_name__ = "LOCKS" __handlers__ = [ LOCKTYPES_HANDLER, LOCK_HANDLER, UNLOCK_HANDLER, LOCKED_HANDLER, (LOCKABLE_HANDLER, PERM_GROUP), (RESTRICTION_HANDLER, REST_GROUP) ]
import random, re @run_async @bot_admin def getlink(bot: Bot, update: Update, args: List[int]): message = update.effective_message if args: pattern = re.compile(r'-\d+') else: message.reply_text("You don't seem to be referring to any chats.") links = "Invite link(s):\n" for chat_id in pattern.findall(message.text): try: chat = bot.getChat(chat_id) bot_member = chat.get_member(bot.id) if bot_member.can_invite_users: invitelink = bot.exportChatInviteLink(chat_id) links += str(chat_id) + ":\n" + invitelink + "\n" else: links += str(chat_id) + ":\nI don't have access to the invite link." + "\n" except BadRequest as excp: links += str(chat_id) + ":\n" + excp.message + "\n" except TelegramError as excp: links += str(chat_id) + ":\n" + excp.message + "\n" message.reply_text(links) GETLINK_HANDLER = CommandHandler("getlink", getlink, pass_args=True, filters=CustomFilters.sudo_filter) dispatcher.add_handler(GETLINK_HANDLER)
file_path = re.findall(r'/files(.*)/download', link) if not file_path: file_path = re.findall(r'/files(.*)', link) file_path = file_path[0] reply = f"Mirrors for <i>{file_path.split('/')[-1]}</i>\n" project = re.findall(r'projects?/(.*?)/files', link)[0] mirrors = f'https://sourceforge.net/settings/mirror_choices?' \ f'projectname={project}&filename={file_path}' page = BeautifulSoup(requests.get(mirrors).content, 'lxml') info = page.find('ul', {'id': 'mirrorList'}).findAll('li') for mirror in info[1:]: name = re.findall(r'\((.*)\)', mirror.text.strip())[0] dl_url = f'https://{mirror["id"]}.dl.sourceforge.net/project/{project}/{file_path}' reply += f'<a href="{dl_url}">{name}</a> ' return reply def useragent(): useragents = BeautifulSoup( requests.get( 'https://developers.whatismybrowser.com/' 'useragents/explore/operating_system_name/android/').content, 'lxml').findAll('td', {'class': 'useragent'}) user_agent = choice(useragents) return user_agent.text DIRECT_HANDLER = CommandHandler("direct", direct_link_generator) dispatcher.add_handler(DIRECT_HANDLER)
pass_args=True) REMOVE_CLEAN_BLUE_TEXT_HANDLER = CommandHandler("unignorecleanbluetext", remove_bluetext_ignore, pass_args=True) ADD_CLEAN_BLUE_TEXT_GLOBAL_HANDLER = CommandHandler( "ignoreglobalcleanbluetext", add_bluetext_ignore_global, pass_args=True) REMOVE_CLEAN_BLUE_TEXT_GLOBAL_HANDLER = CommandHandler( "unignoreglobalcleanbluetext", remove_bluetext_ignore_global, pass_args=True) LIST_CLEAN_BLUE_TEXT_HANDLER = CommandHandler("listcleanbluetext", bluetext_ignore_list) CLEAN_BLUE_TEXT_HANDLER = MessageHandler(Filters.command & Filters.group, clean_blue_text_must_click) dispatcher.add_handler(SET_CLEAN_BLUE_TEXT_HANDLER) dispatcher.add_handler(ADD_CLEAN_BLUE_TEXT_HANDLER) dispatcher.add_handler(REMOVE_CLEAN_BLUE_TEXT_HANDLER) dispatcher.add_handler(ADD_CLEAN_BLUE_TEXT_GLOBAL_HANDLER) dispatcher.add_handler(REMOVE_CLEAN_BLUE_TEXT_GLOBAL_HANDLER) dispatcher.add_handler(LIST_CLEAN_BLUE_TEXT_HANDLER) dispatcher.add_handler(CLEAN_BLUE_TEXT_HANDLER, BLUE_TEXT_CLEAN_GROUP) __mod_name__ = "BLUETEXT CLEANING" __handlers__ = [ SET_CLEAN_BLUE_TEXT_HANDLER, ADD_CLEAN_BLUE_TEXT_HANDLER, REMOVE_CLEAN_BLUE_TEXT_HANDLER, ADD_CLEAN_BLUE_TEXT_GLOBAL_HANDLER, REMOVE_CLEAN_BLUE_TEXT_GLOBAL_HANDLER, LIST_CLEAN_BLUE_TEXT_HANDLER, (CLEAN_BLUE_TEXT_HANDLER, BLUE_TEXT_CLEAN_GROUP) ]
update.effective_message.reply_text(res['message']) except Exception: if r.status_code == 404: update.effective_message.reply_text('Failed to reach dogbin') else: update.effective_message.reply_text('Unknown error occured') r.raise_for_status() document = r.json()['document'] key = document['_id'] views = document['viewCount'] reply = f'Stats for **[/{key}]({BASE_URL}/{key})**:\nViews: `{views}`' update.effective_message.reply_text(reply, parse_mode=ParseMode.MARKDOWN) __help__ = """ - /paste: Create a paste or a shortened url using [dogbin](https://del.dog) - /getpaste: Get the content of a paste or shortened url from [dogbin](https://del.dog) - /pastestats: Get stats of a paste or shortened url from [dogbin](https://del.dog) """ __mod_name__ = "DOGBIN" PASTE_HANDLER = DisableAbleCommandHandler("paste", paste, pass_args=True) GET_PASTE_HANDLER = DisableAbleCommandHandler("getpaste", get_paste_content, pass_args=True) PASTE_STATS_HANDLER = DisableAbleCommandHandler("pastestats", get_paste_stats, pass_args=True) dispatcher.add_handler(PASTE_HANDLER) dispatcher.add_handler(GET_PASTE_HANDLER) dispatcher.add_handler(PASTE_STATS_HANDLER)
def main(): test_handler = CommandHandler("test", test) start_handler = CommandHandler("start", start, pass_args=True) IMDB_HANDLER = CommandHandler('imdb', imdb, pass_args=True) IMDB_SEARCHDATAHANDLER = CallbackQueryHandler(imdb_searchdata) start_callback_handler = CallbackQueryHandler(send_start, pattern=r"bot_start") dispatcher.add_handler(start_callback_handler) help_handler = CommandHandler("help", get_help) help_callback_handler = CallbackQueryHandler(help_button, pattern=r"help_") settings_handler = CommandHandler("settings", get_settings) settings_callback_handler = CallbackQueryHandler(settings_button, pattern=r"stngs_") source_handler = CommandHandler("source", source) migrate_handler = MessageHandler(Filters.status_update.migrate, migrate_chats) M_CONNECT_BTN_HANDLER = CallbackQueryHandler(m_connect_button, pattern=r"main_connect") # dispatcher.add_handler(test_handler) dispatcher.add_handler(start_handler) dispatcher.add_handler(help_handler) dispatcher.add_handler(settings_handler) dispatcher.add_handler(help_callback_handler) dispatcher.add_handler(settings_callback_handler) dispatcher.add_handler(migrate_handler) dispatcher.add_handler(source_handler) dispatcher.add_handler(M_CONNECT_BTN_HANDLER) dispatcher.add_handler(IMDB_HANDLER) dispatcher.add_handler(IMDB_SEARCHDATAHANDLER) # dispatcher.add_error_handler(error_callback) if WEBHOOK: LOGGER.info("Using webhooks.") updater.start_webhook(listen="127.0.0.1", port=PORT, url_path=TOKEN) if CERT_PATH: updater.bot.set_webhook(url=URL + TOKEN, certificate=open(CERT_PATH, 'rb')) else: updater.bot.set_webhook(url=URL + TOKEN) else: LOGGER.info("Singappennubot running...") updater.start_polling(timeout=15, read_latency=4) updater.idle()
def __migrate__(old_chat_id, new_chat_id): sql.migrate_chat(old_chat_id, new_chat_id) def __chat_settings__(chat_id, user_id): return "This chat has had it's rules set: `{}`".format( bool(sql.get_rules(chat_id))) __help__ = """ - /rules: get the rules for this chat. *Admin only:* - /setrules <your rules here>: set the rules for this chat. - /clearrules: clear the rules for this chat. """ __mod_name__ = "RULES" GET_RULES_HANDLER = CommandHandler("rules", get_rules, filters=Filters.group) SET_RULES_HANDLER = CommandHandler("setrules", set_rules, filters=Filters.group) RESET_RULES_HANDLER = CommandHandler("clearrules", clear_rules, filters=Filters.group) dispatcher.add_handler(GET_RULES_HANDLER) dispatcher.add_handler(SET_RULES_HANDLER) dispatcher.add_handler(RESET_RULES_HANDLER)
f"<b>Admin:</b> {mention_html(user.id, user.first_name)}\n" f"Message deleted.") else: update.effective_message.reply_text("Whadya want to delete?") return "" __help__ = """ *Admin only:* - /del: deletes the message you replied to - /purge: deletes all messages between this and the replied to message. - /purge <integer X>: deletes the replied message, and X messages following it if replied to a message. - /purge <integer X>: deletes the number of messages starting from bottom. (Counts manaully deleted messages too) """ DELETE_HANDLER = DisableAbleCommandHandler("del", del_message, filters=Filters.group) PURGE_HANDLER = DisableAbleCommandHandler("purge", purge, filters=Filters.group, pass_args=True) dispatcher.add_handler(DELETE_HANDLER) dispatcher.add_handler(PURGE_HANDLER) __mod_name__ = "PURGE" __command_list__ = ["del", "purge"] __handlers__ = [DELETE_HANDLER, PURGE_HANDLER]
- /get <notename>: get the note with this notename - #<notename>: same as /get - /notes or /saved: list all saved notes in this chat If you would like to retrieve the contents of a note without any formatting, use `/get <notename> noformat`. This can \ be useful when updating a current note. *Admin only:* - /save <notename> <notedata>: saves notedata as a note with name notename A button can be added to a note by using standard markdown link syntax - the link should just be prepended with a \ `buttonurl:` section, as such: `[somelink](buttonurl:example.com)`. Check /markdownhelp for more info. - /save <notename>: save the replied message as a note with name notename - /clear <notename>: clear note with this name """ __mod_name__ = "NOTES" GET_HANDLER = CommandHandler("get", cmd_get, pass_args=True) HASH_GET_HANDLER = RegexHandler(r"^#[^\s]+", hash_get) SAVE_HANDLER = CommandHandler("save", save) DELETE_HANDLER = CommandHandler("clear", clear, pass_args=True) LIST_HANDLER = DisableAbleCommandHandler(["notes", "saved"], list_notes, admin_ok=True) 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)
cpuu += "--- CPU Usage Per Core ---\n" for i, percentage in enumerate(psutil.cpu_percent(percpu=True)): cpuu += f"Core {i}: `{percentage}%`\n" cpuu += f"Total CPU Usage: `{psutil.cpu_percent()}%`\n" # RAM Usage svmem = psutil.virtual_memory() memm = "--- Memory Usage ---\n" memm += f"Total: `{get_size(svmem.total)}`\n" memm += f"Available: `{get_size(svmem.available)}`\n" memm += f"Used: `{get_size(svmem.used)}`\n" memm += f"Percentage: `{svmem.percent}%`\n" reply = str(stat)+ str(softw) + str(cpuu) + str(memm) + "\n" bot.send_message(chat.id, reply, parse_mode=ParseMode.MARKDOWN) __help__ = """ - /system : To know System status - /speed or - /speedtest: To find Speed """ SPEED_TEST_HANDLER = DisableAbleCommandHandler(["speedtest","speed"], speedtestxyz, filters=CustomFilters.sudo_filter) SPEED_TEST_CALLBACKHANDLER = CallbackQueryHandler(speedtestxyz_callback, pattern='speedtest_.*') STATUS_HANDLER = CommandHandler("system", status, filters=CustomFilters.sudo_filter) dispatcher.add_handler(SPEED_TEST_HANDLER) dispatcher.add_handler(SPEED_TEST_CALLBACKHANDLER) dispatcher.add_handler(STATUS_HANDLER) __mod_name__ = "SYSTEM INFO" __command_list__ = ["speedtest"] __handlers__ = [SPEED_TEST_HANDLER, SPEED_TEST_CALLBACKHANDLER]
msg.reply_text(rep, timeout=60) except CFError as e: bot.send_message(OWNER_ID, f"lydia error: {e} occurred in {chat_id}!") __mod_name__ = "LYDIA/CHATBOT" __help__ = """ Commands - /elydia : Enables Lydia mode in the chat. - /dlydia : Disables Lydia mode in the chat. """ ADD_CHAT_HANDLER = CommandHandler("elydia", add_chat, filters=CustomFilters.dev_filter) REMOVE_CHAT_HANDLER = CommandHandler("dlydia", remove_chat, filters=CustomFilters.dev_filter) LYDIA_HANDLER = MessageHandler( Filters.text & (~Filters.regex(r"^#[^\s]+") & ~Filters.regex(r"^!") & ~Filters.regex(r"^s\/")), lydia) # Filters for ignoring #note messages, !commands and sed. dispatcher.add_handler(ADD_CHAT_HANDLER) dispatcher.add_handler(REMOVE_CHAT_HANDLER) dispatcher.add_handler(LYDIA_HANDLER)
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 __help__ = """ - /reverse: Does a reverse image search of the media which it was replied to. """ __mod_name__ = "REVERSE IMAGE SEARCH" REVERSE_HANDLER = DisableAbleCommandHandler("reverse", reverse, pass_args=True, admin_ok=True) dispatcher.add_handler(REVERSE_HANDLER)
return f"<b>About user:</b>\n{me}\n<b>What others say:</b>\n{bio}" elif bio: return f"<b>What others say:</b>\n{bio}\n" elif me: return f"<b>About user:</b>\n{me}" else: return "" __help__ = """ - /setbio <text>: while replying, will save another user's bio - /bio: will get your or another user's bio. This cannot be set by yourself. - /setme <text>: will set your info - /me: will get your or another user's info """ SET_BIO_HANDLER = DisableAbleCommandHandler("setbio", set_about_bio) GET_BIO_HANDLER = DisableAbleCommandHandler("bio", about_bio, pass_args=True) SET_ABOUT_HANDLER = DisableAbleCommandHandler("setme", set_about_me) GET_ABOUT_HANDLER = DisableAbleCommandHandler("me", about_me, pass_args=True) dispatcher.add_handler(SET_BIO_HANDLER) dispatcher.add_handler(GET_BIO_HANDLER) dispatcher.add_handler(SET_ABOUT_HANDLER) dispatcher.add_handler(GET_ABOUT_HANDLER) __mod_name__ = "BIOS/ABOUTS" __command_list__ = ["setbio", "bio", "setme", "me"] __handlers__ = [SET_BIO_HANDLER, GET_BIO_HANDLER, SET_ABOUT_HANDLER, GET_ABOUT_HANDLER]
"You forgot to mention the currency code to convert into.") return request_url = f"https://www.alphavantage.co/query?function=CURRENCY_EXCHANGE_RATE&from_currency={orig_cur}&to_currency={new_cur}&apikey={CASH_API_KEY}" response = requests.get(request_url).json() try: current_rate = float(response['Realtime Currency Exchange Rate'] ['5. Exchange Rate']) except KeyError: update.effective_message.reply_text(f"Currency Not Supported.") return new_cur_amount = round(orig_cur_amount * current_rate, 5) update.effective_message.reply_text( f"{orig_cur_amount} {orig_cur} = {new_cur_amount} {new_cur}") else: update.effective_message.reply_text(__help__) __help__ = """ - /cash : currency converter example syntax: /cash 1 USD INR """ CONVERTER_HANDLER = CommandHandler('cash', convert) dispatcher.add_handler(CONVERTER_HANDLER) __mod_name__ = "CURRENCY CONVERTER" __command_list__ = ["cash"] __handlers__ = [CONVERTER_HANDLER]
from Singappennubot.modules.helper_funcs.chat_status import is_user_admin, user_admin from Singappennubot.modules.helper_funcs.extraction import extract_user #sleep how many times after each edit in 'police' EDIT_SLEEP = 1 #edit how many times in 'police' EDIT_TIMES = 6 police_siren = [ "🔴🔴🔴⬜️⬜️⬜️🔵🔵🔵\n🔴🔴🔴⬜️⬜️⬜️🔵🔵🔵\n🔴🔴🔴⬜️⬜️⬜️🔵🔵🔵", "🔵🔵🔵⬜️⬜️⬜️🔴🔴🔴\n🔵🔵🔵⬜️⬜️⬜️🔴🔴🔴\n🔵🔵🔵⬜️⬜️⬜️🔴🔴🔴" ] @user_admin @run_async def police(bot: Bot, update: Update): msg = update.effective_message.reply_text('തോമാസുട്ടി.... വിട്ടോടാ') for x in range(EDIT_TIMES): msg.edit_text(police_siren[x % 2]) time.sleep(EDIT_SLEEP) msg.edit_text('🚔Pling! Police Car was Breakdown') POLICE_HANDLER = DisableAbleCommandHandler("police", police) dispatcher.add_handler(POLICE_HANDLER) __command_list__ = ["police"] __handlers__ = [POLICE_HANDLER]
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 kick. """ __mod_name__ = "WARNINGS" WARN_HANDLER = CommandHandler("warn", warn_user, pass_args=True, filters=Filters.group) RESET_WARN_HANDLER = CommandHandler(["resetwarn", "resetwarns"], reset_warns, pass_args=True, filters=Filters.group) CALLBACK_QUERY_HANDLER = CallbackQueryHandler(button, pattern=r"rm_warn") MYWARNS_HANDLER = DisableAbleCommandHandler("warns", warns, pass_args=True, 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, pass_args=True, filters=Filters.group) WARN_STRENGTH_HANDLER = CommandHandler("strongwarn", set_warn_strength, pass_args=True, filters=Filters.group) dispatcher.add_handler(WARN_HANDLER) dispatcher.add_handler(CALLBACK_QUERY_HANDLER) dispatcher.add_handler(RESET_WARN_HANDLER) dispatcher.add_handler(MYWARNS_HANDLER) dispatcher.add_handler(ADD_WARN_HANDLER) dispatcher.add_handler(RM_WARN_HANDLER) dispatcher.add_handler(LIST_WARN_HANDLER) dispatcher.add_handler(WARN_LIMIT_HANDLER) dispatcher.add_handler(WARN_STRENGTH_HANDLER) dispatcher.add_handler(WARN_FILTER_HANDLER, WARN_HANDLER_GROUP)
from Singappennubot.modules.disable import DisableAbleCommandHandler from Singappennubot.modules.helper_funcs.extraction import extract_user def tts(bot: Bot, update: Update, args): current_time = datetime.strftime(datetime.now(), "%d.%m.%Y %H:%M:%S") filename = datetime.now().strftime("%d%m%y-%H%M%S%f") reply = " ".join(args) 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) __help__ = """ Text to speech - /tts <your text> """ __mod_name__ = "TEXT TO SPEECH" dispatcher.add_handler(CommandHandler('tts', tts, pass_args=True))
k = 273.15 c = k if (c > (k - 1)) and (c < k) else c temp = str(round((c - k))) return temp def fahr(c): c1 = 9 / 5 c2 = 459.67 tF = c * c1 - c2 if tF < 0 and tF > -1: tF = 0 temp = str(round(tF)) return temp reply = f"⛅️*Current🌦Weather*🏖\n\n🌐*Country Name:* {country_name}\n🗺*City:* {cityname}\n\n🔥*Temperature:* `{celsius(curtemp)}°C ({fahr(curtemp)}ºF), feels like {celsius(feels_like)}°C ({fahr(feels_like)}ºF) \n`⛱*Condition:* `{condmain}, {conddet}` {icon}\n⛲️*Humidity:* `{humidity}%`\n🎐*Wind:* `{kmph[0]} km/h`\n" update.effective_message.reply_text("{}".format(reply), parse_mode=ParseMode.MARKDOWN, disable_web_page_preview=True) return __help__ = """ - /weather <city>: gets weather info in a particular place using openweathermap.org api """ __mod_name__ = "WEATHER" WEATHER_HANDLER = DisableAbleCommandHandler("weather", weather, pass_args=True) dispatcher.add_handler(WEATHER_HANDLER)
message = update.effective_message if len(args) == 0: update.effective_message.reply_text( "That was a funny joke, but no really, put in a location") try: geolocator = Nominatim(user_agent="SkittBot") location = " ".join(args) geoloc = geolocator.geocode(location) chat_id = update.effective_chat.id lon = geoloc.longitude lat = geoloc.latitude the_loc = Location(lon, lat) gm = "https://www.google.com/maps/search/{},{}".format(lat, lon) bot.send_location(chat_id, location=the_loc) update.message.reply_text("Open with: [Google Maps]({})".format(gm), parse_mode=ParseMode.MARKDOWN, disable_web_page_preview=True) except AttributeError: update.message.reply_text("I can't find that") __help__ = """ - /gps <location>: get gps location """ __mod_name__ = "GPS" GPS_HANDLER = DisableAbleCommandHandler("gps", gps, pass_args=True) dispatcher.add_handler(GPS_HANDLER)
def feedback(bot: Bot, update: Update): name = update.effective_message.from_user.first_name message = update.effective_message userid = message.from_user.id text = message.text[len('/feedback '):] feed_text = f"Singappennubot's *New* feedback from [{name}](tg://user?id={userid})\n\nfeed: {text}" bot.send_message(-1001199155295, feed_text, parse_mode=ParseMode.MARKDOWN) text = html.escape(text) reply_text = f"Thankyou for giving us your feedback." message.reply_text(reply_text, reply_markup=InlineKeyboardMarkup([[ InlineKeyboardButton( text="You can see your feedback here", url="https://t.me/Sur_vivor") ]])) __help__ = """ - /feedback : You can give us your feedbacks can can see your feeds here. """ __mod_name__ = "FEEDBACK" feed_handle = DisableAbleCommandHandler("feedback", feedback) dispatcher.add_handler(feed_handle)
time_list.reverse() ping_time += ":".join(time_list) return ping_time @run_async def ping(bot: Bot, update: Update): start_time = time.time() requests.get('https://api.telegram.org') end_time = time.time() ping_time = str(round((end_time - start_time), 2) % 60) uptime = get_readable_time((time.time() - StartTime)) update.effective_message.reply_text(f"� !\n��<b>Reply took:</b> {ping_time}s\n🔮<b>Service Uptime:</b> {uptime}", parse_mode=ParseMode.HTML) @run_async def uptime(bot: Bot, update: Update): uptime = get_readable_time((time.time() - StartTime)) update.effective_message.reply_text(f"🔮Service Uptime: {uptime}") __help__ = """ - /ping : - /uptime: Find last service update time """ __mod_name__ = "PING" PING_HANDLER = DisableAbleCommandHandler("ping", ping) UPTIME_HANDLER = DisableAbleCommandHandler("uptime", uptime) dispatcher.add_handler(UPTIME_HANDLER) dispatcher.add_handler(PING_HANDLER)
else: tekstr = trl.translate(text, dest=dest_lang, src=source_lang) message.reply_text( "Translated from `{}` to `{}`:\n`{}`".format( source_lang, dest_lang, tekstr.text), parse_mode=ParseMode.MARKDOWN) except IndexError: update.effective_message.reply_text( "Reply to messages or write messages from other languages for translating into the intended language\n\nExample: `/tr en ml` to translate from English to Malayalam\nOr use: `/tr ml` for automatic detection and translating it into Malayalam.\nSee [List of Language Codes](https://telegra.ph/%C5%9E%E0%B8%AA%E2%84%9D%E0%B8%AA%D1%92-06-28) for a list of language codes.", parse_mode="markdown", disable_web_page_preview=True) except ValueError: update.effective_message.reply_text( "The intended language is not found!") else: return __help__ = """ - /tr (language code) as reply to a long message. """ TRANSLATE_HANDLER = DisableAbleCommandHandler("tr", totranslate) dispatcher.add_handler(TRANSLATE_HANDLER) __mod_name__ = "TRANSLATOR" __command_list__ = ["tr"] __handlers__ = [TRANSLATE_HANDLER]
INTEGRATE_HANDLER = DisableAbleCommandHandler("integrate", integrate, pass_args=True) ZEROES_HANDLER = DisableAbleCommandHandler("zeroes", zeroes, pass_args=True) TANGENT_HANDLER = DisableAbleCommandHandler("tangent", tangent, pass_args=True) AREA_HANDLER = DisableAbleCommandHandler("area", area, pass_args=True) COS_HANDLER = DisableAbleCommandHandler("cos", cos, pass_args=True) SIN_HANDLER = DisableAbleCommandHandler("sin", sin, pass_args=True) TAN_HANDLER = DisableAbleCommandHandler("tan", tan, pass_args=True) ARCCOS_HANDLER = DisableAbleCommandHandler("arccos", arccos, pass_args=True) ARCSIN_HANDLER = DisableAbleCommandHandler("arcsin", arcsin, pass_args=True) ARCTAN_HANDLER = DisableAbleCommandHandler("arctan", arctan, pass_args=True) ABS_HANDLER = DisableAbleCommandHandler("abs", abs, pass_args=True) LOG_HANDLER = DisableAbleCommandHandler("log", log, pass_args=True) dispatcher.add_handler(SIMPLIFY_HANDLER) dispatcher.add_handler(FACTOR_HANDLER) dispatcher.add_handler(DERIVE_HANDLER) dispatcher.add_handler(INTEGRATE_HANDLER) dispatcher.add_handler(ZEROES_HANDLER) dispatcher.add_handler(TANGENT_HANDLER) dispatcher.add_handler(AREA_HANDLER) dispatcher.add_handler(COS_HANDLER) dispatcher.add_handler(SIN_HANDLER) dispatcher.add_handler(TAN_HANDLER) dispatcher.add_handler(ARCCOS_HANDLER) dispatcher.add_handler(ARCSIN_HANDLER) dispatcher.add_handler(ARCTAN_HANDLER) dispatcher.add_handler(ABS_HANDLER) dispatcher.add_handler(LOG_HANDLER)
@run_async def shellExecute(bot: Bot, update: Update): cmd = update.message.text.split(' ', maxsplit=1) if len(cmd) == 1: sendMessage("No command provided!", bot, update) return LOGGER.info(cmd) output = shell(cmd[1]) if output[1].decode(): LOGGER.error(f"Shell: {output[1].decode()}") if len(output[0].decode()) > 4000: with open("shell.txt", 'w') as f: f.write(f"Output\n-----------\n{output[0].decode()}\n") if output[1]: f.write(f"STDError\n-----------\n{output[1].decode()}\n") with open("shell.txt", 'rb') as f: bot.send_document(document=f, filename=f.name, reply_to_message_id=update.message.message_id, chat_id=update.message.chat_id) else: if output[1].decode(): sendMessage(f"<code>{output[1].decode()}</code>", bot, update) return else: sendMessage(f"<code>{output[0].decode()}</code>", bot, update) shell_handler = CommandHandler(('sh', 'shell'), shellExecute) dispatcher.add_handler(shell_handler)
pass_args=True, filters=CustomFilters.sudo_filter | CustomFilters.support_filter) GBAN_LIST = CommandHandler("gbanlist", gbanlist, filters=CustomFilters.sudo_filter | CustomFilters.support_filter) GBAN_STATUS = CommandHandler("gbanstat", gbanstat, pass_args=True, filters=Filters.group) CHECK_GBAN_HANDLER = CommandHandler("checkgb", check_gbans, filters=Filters.user(OWNER_ID)) CLEAN_GBAN_HANDLER = CommandHandler("cleangb", clear_gbans, filters=Filters.user(OWNER_ID)) GBAN_ENFORCER = MessageHandler(Filters.all & Filters.group, enforce_gban) dispatcher.add_handler(GBAN_HANDLER) dispatcher.add_handler(UNGBAN_HANDLER) dispatcher.add_handler(GBAN_LIST) dispatcher.add_handler(GBAN_STATUS) dispatcher.add_handler(CHECK_GBAN_HANDLER) dispatcher.add_handler(CLEAN_GBAN_HANDLER) if STRICT_GBAN: # enforce GBANS if this is set dispatcher.add_handler(GBAN_ENFORCER, GBAN_ENFORCE_GROUP)
from telegram import Update, Bot, ParseMode from telegram.ext import run_async from Singappennubot.modules.disable import DisableAbleCommandHandler from Singappennubot import dispatcher from requests import get @run_async def ud(bot: Bot, update: Update): message = update.effective_message text = message.text[len('/ud '):] results = get( f'http://api.urbandictionary.com/v0/define?term={text}').json() reply_text = f'ℹ️ *{text}*\n\n👉🏻 {results["list"][0]["definition"]}\n\n📌 _{results["list"][0]["example"]}_' message.reply_text(reply_text, parse_mode=ParseMode.MARKDOWN) __help__ = """ - /ud:{word} Type the word or expression you want to search use. like /ud telegram Word: Telegram Definition: A once-popular system of telecommunications, in which the sender would contact the telegram service and speak their [message] over the [phone]. The person taking the message would then send it, via a teletype machine, to a telegram office near the receiver's [address]. The message would then be hand-delivered to the addressee. From 1851 until it discontinued the service in 2006, Western Union was the best-known telegram service in the world. """ __mod_name__ = "URBAN DICTIONARY" ud_handle = DisableAbleCommandHandler("ud", ud) dispatcher.add_handler(ud_handle)
""" RUNS_HANDLER = DisableAbleCommandHandler("runs", runs) SLAP_HANDLER = DisableAbleCommandHandler("slap", slap, pass_args=True) 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) TABLE_HANDLER = DisableAbleCommandHandler("table", table) JUDGE_HANDLER = DisableAbleCommandHandler("judge", judge) WEEBIFY_HANDLER = DisableAbleCommandHandler("weebify", weebify, pass_args=True) SHOUT_HANDLER = DisableAbleCommandHandler("shout", shout, pass_args=True) dispatcher.add_handler(RUNS_HANDLER) dispatcher.add_handler(SLAP_HANDLER) dispatcher.add_handler(ROLL_HANDLER) dispatcher.add_handler(TOSS_HANDLER) dispatcher.add_handler(SHRUG_HANDLER) dispatcher.add_handler(BLUETEXT_HANDLER) dispatcher.add_handler(RLG_HANDLER) dispatcher.add_handler(DECIDE_HANDLER) dispatcher.add_handler(TABLE_HANDLER) dispatcher.add_handler(JUDGE_HANDLER) dispatcher.add_handler(WEEBIFY_HANDLER) dispatcher.add_handler(SHOUT_HANDLER) __mod_name__ = "FUN" __command_list__ = ["runs", "slap", "roll", "toss", "shrug", "bluetext", "rlg", "decide", "table", "judge", "weebify", "shout"] __handlers__ = [RUNS_HANDLER, SLAP_HANDLER, ROLL_HANDLER, TOSS_HANDLER, SHRUG_HANDLER, BLUETEXT_HANDLER, RLG_HANDLER,
result = cas.banchecker(user.id) text += str(result) for mod in USER_INFO: if mod.__mod_name__ == "Users": continue try: mod_info = mod.__user_info__(user.id) except TypeError: mod_info = mod.__user_info__(user.id, chat.id) if mod_info: text += "\n" + mod_info try: profile = bot.get_user_profile_photos(user.id).photos[0][-1] bot.sendChatAction(chat.id, "upload_photo") bot.send_photo(chat.id, photo=profile, caption=(text), parse_mode=ParseMode.HTML, disable_web_page_preview=True) except IndexError: update.effective_message.reply_text(text, parse_mode=ParseMode.HTML, disable_web_page_preview=True) INFO_HANDLER = DisableAbleCommandHandler(["info", "whois"], info, pass_args=True) dispatcher.add_handler(INFO_HANDLER)