except Unauthorized: update.effective_message.reply_text("Contact me in PM first to get donation information.") def migrate_chats(bot: Bot, update: Update): msg = update.effective_message # type: Optional[Message] if msg.migrate_to_chat_id: old_chat = update.effective_chat.id new_chat = msg.migrate_to_chat_id elif msg.migrate_from_chat_id: old_chat = msg.migrate_from_chat_id new_chat = update.effective_chat.id else: return LOGGER.info("Migrating from %s, to %s", str(old_chat), str(new_chat)) for mod in MIGRATEABLE: mod.__migrate__(old_chat, new_chat) LOGGER.info("Successfully migrated!") raise DispatcherHandlerStop @run_async def kcfrsct_fnc(bot: Bot, update: Update): query = update.callback_query user = update.effective_user _match = re.match(r"rsct_(.*)_33801", query.data) # ensure no spinny white circle if _match: try:
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(donate_handler) # dispatcher.add_error_handler(error_callback) if WEBHOOK: LOGGER.info("Using webhooks.") updater.start_webhook(listen="0.0.0.0", 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("Using long polling.") updater.start_polling(timeout=15, read_latency=4) updater.idle() if __name__ == '__main__': LOGGER.info("Modullar uğurla yükləndi: " + str(ALL_MODULES)) main()
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(donate_handler) # dispatcher.add_error_handler(error_callback) if WEBHOOK: LOGGER.info("Using webhooks.") updater.start_webhook(listen="0.0.0.0", 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("Using long polling.") updater.start_polling(timeout=15, read_latency=4) updater.idle() if __name__ == '__main__': LOGGER.info("Yüklenen Modüller: " + str(ALL_MODULES)) main()
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(donate_handler) # dispatcher.add_error_handler(error_callback) if WEBHOOK: LOGGER.info("Using webhooks.") updater.start_webhook(listen="0.0.0.0", 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("Using long polling.") updater.start_polling(timeout=15, read_latency=4) updater.idle() if __name__ == '__main__': LOGGER.info("الوحدات المحمولة بنجاح: " + str(ALL_MODULES)) main()
if isfile(f) and f.endswith(".py") and not f.endswith("__init__.py") ] if LOAD or NO_LOAD: to_load = LOAD if to_load: if not all( any(mod == module_name for module_name in all_modules) for mod in to_load): LOGGER.error("Invalid loadorder names. Quitting.") quit(1) all_modules = sorted(set(all_modules) - set(to_load)) to_load = list(all_modules) + to_load else: to_load = all_modules if NO_LOAD: LOGGER.info("Not loading: {}".format(NO_LOAD)) return [item for item in to_load if item not in NO_LOAD] return to_load return all_modules ALL_MODULES = __list_all_modules() LOGGER.info("Modules to load: %s", str(ALL_MODULES)) __all__ = ALL_MODULES + ["ALL_MODULES"]
def log_input(update): user = update.effective_user.id chat = update.effective_chat.id LOGGER.info("IN: {} (user={}, chat={})".format( update.effective_message.text, user, chat))
def ungban(bot: Bot, update: Update, args: List[str]): message = update.effective_message # type: Optional[Message] user_id = extract_user(message, args) if not user_id: message.reply_text("You don't seem to be referring to a user.") return user_chat = bot.get_chat(user_id) if user_chat.type != 'private': message.reply_text("That's not a user!") return banner = update.effective_user # type: Optional[User] message.reply_text("I'll give {} a second chance, globally.".format( user_chat.first_name)) send_to_list( bot, SUDO_USERS + SUPPORT_USERS, "[{}](tg://user?id={}) has ungbanned user [{}](tg://user?id={})". format(escape_markdown(banner.first_name), banner.id, escape_markdown(user_chat.first_name), user_chat.id), markdown=True) sql.ungban_user(user_id) chats = get_all_chats() for chat in chats: chat_id = chat.chat_id # Check if this group has disabled gbans if not sql.does_chat_gban(chat_id): continue try: member = bot.get_chat_member(chat_id, user_id) from tg_bot import LOGGER LOGGER.info(f"{member.status}") if member.status == 'kicked': bot.unban_chat_member(chat_id, user_id) except BadRequest as excp: from tg_bot import LOGGER LOGGER.exception("WTH IS THIS '{}'".format(excp.message)) if excp.message == "User is an administrator of the chat": pass elif excp.message == "Chat not found": pass elif excp.message == "Not enough rights to restrict/unrestrict chat member": pass elif excp.message == "User_not_participant": pass elif excp.message == "Method is available for supergroup and channel chats only": pass elif excp.message == "Not in the chat": pass else: message.reply_text("Could not un-gban due to: {}".format( excp.message)) bot.send_message( OWNER_ID, "Could not un-gban due to: {}".format(excp.message)) return except TelegramError: pass send_to_list(bot, SUDO_USERS + SUPPORT_USERS, "un-gban complete!") message.reply_text("Person has been un-gbanned.")
def fed_ban(bot: Bot, update: Update, args: List[str]): chat = update.effective_chat # type: Optional[Chat] user = update.effective_user # type: Optional[User] fed_id = sql.get_fed_id(chat.id) if not fed_id: update.effective_message.reply_text("This group is not a part of any federation!") return info = sql.get_fed_info(fed_id) OW = bot.get_chat(info['owner']) HAHA = OW.id FEDADMIN = sql.all_fed_users(fed_id) FEDADMIN.append(int(HAHA)) if is_user_fed_admin(fed_id, user.id) == False: update.effective_message.reply_text("Only federation admins can do this!") return message = update.effective_message # type: Optional[Message] user_id, reason = extract_user_and_text(message, args) fban, fbanreason = sql.get_fban_user(fed_id, user_id) if not user_id: message.reply_text("You don't seem to be referring to a user.") return if user_id == bot.id: message.reply_text("Nice try!") return if is_user_fed_owner(fed_id, user_id) == True: message.reply_text("You can't ban the federation owner!") return if is_user_fed_admin(fed_id, user_id) == True: message.reply_text("Why are you trying to ban a federation admin?") return if user_id == OWNER_ID: message.reply_text("I'm not gonna ban my owner!") return if int(user_id) in SUDO_USERS: message.reply_text("This person is sudo so I won't ban them!") return if int(user_id) in WHITELIST_USERS: message.reply_text("This person is whitelisted so I can't ban them!") return try: user_chat = bot.get_chat(user_id) except BadRequest as excp: message.reply_text(excp.message) return if user_chat.type != 'private': message.reply_text("That's not a user!") return if fban: user_target = mention_html(user_chat.id, user_chat.first_name) fed_name = info['fname'] starting = "<b>FedBan reason updated</b>" \ "\n<b>Federation:</b> {}" \ "\n<b>Federation Admin:</b> {}" \ "\n<b>User:</b> {}" \ "\n<b>User ID:</b> <code>{}</code>" \ "\n<b>Reason:</b> {}".format(fed_name, mention_html(user.id, user.first_name), mention_html(user_chat.id, user_chat.first_name), user_chat.id, reason) update.effective_message.reply_text(starting, parse_mode=ParseMode.HTML) if reason == "": reason = "No reason given." temp = sql.un_fban_user(fed_id, user_id) if not temp: message.reply_text("Failed to update fban reason!") return x = sql.fban_user(fed_id, user_id, user_chat.first_name, user_chat.last_name, user_chat.username, reason) if not x: message.reply_text("Failed to ban from the federation! If this problem persists, reach out to us @CtrlSupport.") return fed_chats = sql.all_fed_chats(fed_id) for chat in fed_chats: try: bot.kick_chat_member(chat, user_id) except BadRequest as excp: if excp.message in FBAN_ERRORS: pass else: LOGGER.warning("Could not fban in {} because: {}".format(chat, excp.message)) except TelegramError: pass send_to_list(bot, FEDADMIN, "<b>FedBan reason updated</b>" \ "\n<b>Federation:</b> {}" \ "\n<b>Federation Admin:</b> {}" \ "\n<b>User:</b> {}" \ "\n<b>User ID:</b> <code>{}</code>" \ "\n<b>Reason:</b> {}".format(fed_name, mention_html(user.id, user.first_name), mention_html(user_chat.id, user_chat.first_name), user_chat.id, reason), html=True) message.reply_text("I've updated the FedBan reason!") return user_target = mention_html(user_chat.id, user_chat.first_name) fed_name = info['fname'] starting = "<b>New FedBan</b>" \ "\n<b>Federation:</b> {}" \ "\n<b>Federation Admin:</b> {}" \ "\n<b>User:</b> {}" \ "\n<b>User ID:</b> <code>{}</code>" \ "\n<b>Reason:</b> {}".format(fed_name, mention_html(user.id, user.first_name), mention_html(user_chat.id, user_chat.first_name), user_chat.id, reason) update.effective_message.reply_text(starting, parse_mode=ParseMode.HTML) if reason == "": reason = "No reason given." x = sql.fban_user(fed_id, user_id, user_chat.first_name, user_chat.last_name, user_chat.username, reason) if not x: message.reply_text("Failed to ban from the federation! If this problem persists, reach out to us @PhoenixSupport.") return fed_chats = sql.all_fed_chats(fed_id) for chat in fed_chats: try: bot.kick_chat_member(chat, user_id) except BadRequest as excp: if excp.message in FBAN_ERRORS: try: dispatcher.bot.getChat(chat) except Unauthorized: sql.chat_leave_fed(chat) LOGGER.info("Chat {} has left fed {} because bot has been kicked.".format(chat, info['fname'])) continue else: LOGGER.warning("Cannot fban in {} because: {}".format(chat, excp.message)) except TelegramError: pass send_to_list(bot, FEDADMIN, "<b>New FedBan</b>" \ "\n<b>Federation:</b> {}" \ "\n<b>Federation Admin:</b> {}" \ "\n<b>User:</b> {}" \ "\n<b>User ID:</b> <code>{}</code>" \ "\n<b>Reason:</b> {}".format(fed_name, mention_html(user.id, user.first_name), mention_html(user_chat.id, user_chat.first_name), user_chat.id, reason), html=True) message.reply_text("{} has been fbanned.".format(mention_html(user_chat.id, user_chat.first_name)), parse_mode=ParseMode.HTML)
def control_panel(bot, update): LOGGER.info("Control panel") chat = update.effective_chat user = update.effective_user # ONLY send help in PM if chat.type != chat.PRIVATE: update.effective_message.reply_text( "Contact me in PM to access the control panel.", reply_markup=InlineKeyboardMarkup([[ InlineKeyboardButton( text="Control Panel", url=f"t.me/{bot.username}?start=controlpanel") ]])) return #Support to run from command handler query = update.callback_query if query: query.message.delete() M_match = re.match(r"cntrl_panel_M", query.data) U_match = re.match(r"cntrl_panel_U", query.data) G_match = re.match(r"cntrl_panel_G", query.data) back_match = re.match(r"help_back", query.data) LOGGER.info(query.data) else: M_match = "Monica is the best bot" #LMAO, don't uncomment if M_match: text = "*Control panel* 🛠" keyboard = [[ InlineKeyboardButton(text="👤 My settings", callback_data="cntrl_panel_U(1)") ]] #Show connected chat and add chat settings button conn = connected(bot, update, chat, user.id, need_admin=False) if conn: chatG = bot.getChat(conn) #admin_list = chatG.get_administrators() #Unused variable #If user admin member = chatG.get_member(user.id) if member.status in ('administrator', 'creator'): text += f"\nConnected chat - *{chatG.title}* (you {member.status})" keyboard += [[ InlineKeyboardButton(text="👥 Group settings", callback_data="cntrl_panel_G_back") ]] elif user.id in SUDO_USERS: text += f"\nConnected chat - *{chatG.title}* (you sudo)" keyboard += [[ InlineKeyboardButton(text="👥 Group settings (SUDO)", callback_data="cntrl_panel_G_back") ]] else: text += f"\nConnected chat - *{chatG.title}* (you aren't an admin!)" else: text += "\nNo chat connected!" keyboard += [[ InlineKeyboardButton(text="Back", callback_data="bot_start") ]] update.effective_message.reply_text( text, reply_markup=InlineKeyboardMarkup(keyboard), parse_mode=ParseMode.MARKDOWN) elif U_match: mod_match = re.match(r"cntrl_panel_U_module\((.+?)\)", query.data) back_match = re.match(r"cntrl_panel_U\((.+?)\)", query.data) chatP = update.effective_chat # type: Optional[Chat] if mod_match: module = mod_match.group(1) R = CHAT_SETTINGS[module].__user_settings__(bot, update, user) text = "You has the following settings for the *{}* module:\n\n".format( CHAT_SETTINGS[module].__mod_name__) + R[0] keyboard = R[1] keyboard += [[ InlineKeyboardButton(text="Back", callback_data="cntrl_panel_U(1)") ]] query.message.reply_text( text=text, arse_mode=ParseMode.MARKDOWN, reply_markup=InlineKeyboardMarkup(keyboard)) elif back_match: text = "*User control panel* 🛠" query.message.reply_text(text=text, parse_mode=ParseMode.MARKDOWN, reply_markup=InlineKeyboardMarkup( paginate_modules( user.id, 0, USER_SETTINGS, "cntrl_panel_U"))) elif G_match: mod_match = re.match(r"cntrl_panel_G_module\((.+?)\)", query.data) prev_match = re.match(r"cntrl_panel_G_prev\((.+?)\)", query.data) next_match = re.match(r"cntrl_panel_G_next\((.+?)\)", query.data) back_match = re.match(r"cntrl_panel_G_back", query.data) chatP = chat conn = connected(bot, update, chat, user.id) if not conn == False: chat = bot.getChat(conn) else: query.message.reply_text(text="Error with connection to chat") exit(1) if mod_match: module = mod_match.group(1) R = CHAT_SETTINGS[module].__chat_settings__( bot, update, chat, chatP, user) if type(R) is list: text = R[0] keyboard = R[1] else: text = R keyboard = [] text = "*{}* has the following settings for the *{}* module:\n\n".format( escape_markdown(chat.title), CHAT_SETTINGS[module].__mod_name__) + text keyboard += [[ InlineKeyboardButton(text="Back", callback_data="cntrl_panel_G_back") ]] query.message.reply_text( text=text, parse_mode=ParseMode.MARKDOWN, reply_markup=InlineKeyboardMarkup(keyboard)) elif prev_match: chat_id = prev_match.group(1) curr_page = int(prev_match.group(2)) chat = bot.get_chat(chat_id) query.message.reply_text(tld( user.id, "send-group-settings").format(chat.title), reply_markup=InlineKeyboardMarkup( paginate_modules(curr_page - 1, 0, CHAT_SETTINGS, "cntrl_panel_G", chat=chat_id))) elif next_match: chat_id = next_match.group(1) next_page = int(next_match.group(2)) chat = bot.get_chat(chat_id) query.message.reply_text(tld( user.id, "send-group-settings").format(chat.title), reply_markup=InlineKeyboardMarkup( paginate_modules(next_page + 1, 0, CHAT_SETTINGS, "cntrl_panel_G", chat=chat_id))) elif back_match: text = "Test" query.message.reply_text(text=text, parse_mode=ParseMode.MARKDOWN, reply_markup=InlineKeyboardMarkup( paginate_modules( user.id, 0, CHAT_SETTINGS, "cntrl_panel_G")))
def new_member(bot: Bot, update: Update): chat = update.effective_chat user = update.effective_user msg = update.effective_message chat_name = chat.title or chat.first or chat.usernam should_welc, cust_welcome, welc_type = sql.get_welc_pref(chat.id) welc_mutes = sql.welcome_mutes(chat.id) user_id = user.id human_checks = sql.get_human_checks(user_id, chat.id) if should_welc: sent = None new_members = update.effective_message.new_chat_members for new_mem in new_members: # Give the owner a special welcome if new_mem.id == OWNER_ID: update.effective_message.reply_text( "Oh, Genos? Let's get this moving.") return ("#USER_JOINED\n" "Bot Owner Just Joined The Chat") # Give the owner a special welcome elif new_mem.id in DEV_USERS: update.effective_message.reply_text( "Whoa! A member of the Heroes Association just joined!") return ( f"{html.escape(chat.title)}\n" f"#USER_JOINED\n" f"<b>User</b>:{mention_html(user.id, user.first_name)}\n" f"<b>ID</b>:{user.id}") # Welcome Sudos elif new_mem.id in SUDO_USERS: update.effective_message.reply_text( "Huh! A Dragon disaster just joined! Stay Alert!") return ( f"{html.escape(chat.title)}\n" f"#USER_JOINED\n" f"<b>User</b>:{mention_html(user.id, user.first_name)}\n" f"<b>ID</b>:{user.id}") # Welcome Support elif new_mem.id in SUPPORT_USERS: update.effective_message.reply_text( "Huh! Someone with a Demon disaster level just joined!") return ( f"{html.escape(chat.title)}\n" f"#USER_JOINED\n" f"<b>User</b>:{mention_html(user.id, user.first_name)}\n" f"<b>ID</b>:{user.id}") # Welcome Whitelisted elif new_mem.id in WHITELIST_USERS: update.effective_message.reply_text( "A disaster level Wolf just joined!") return ( f"{html.escape(chat.title)}\n" f"#USER_JOINED\n" f"<b>User</b>:{mention_html(user.id, user.first_name)}\n" f"<b>ID</b>:{user.id}") # Don't welcome yourself elif new_mem.id == bot.id: update.effective_message.reply_text("Watashi wa kitaa!") continue else: # If welcome message is media, send with appropriate function if welc_type != sql.Types.TEXT and welc_type != sql.Types.BUTTON_TEXT: ENUM_FUNC_MAP[welc_type](chat.id, cust_welcome) return # else, move on first_name = new_mem.first_name or "PersonWithNoName" # edge case of empty name - occurs for some bugs. if cust_welcome: if cust_welcome == sql.DEFAULT_WELCOME: cust_welcome = random.choice( sql.DEFAULT_WELCOME_MESSAGES).format( first=first_name) # LOGGER.info("Custom Message: {}".format(cust_welcome)) if new_mem.last_name: fullname = "{} {}".format(first_name, new_mem.last_name) else: fullname = first_name count = chat.get_members_count() mention = mention_markdown(new_mem.id, first_name) if new_mem.username: username = "******" + escape_markdown(new_mem.username) else: username = mention valid_format = escape_invalid_curly_brackets( cust_welcome, VALID_WELCOME_FORMATTERS) res = valid_format.format( first=escape_markdown(first_name), last=escape_markdown(new_mem.last_name or first_name), fullname=escape_markdown(fullname), username=username, mention=mention, count=count, chatname=escape_markdown(chat.title), id=new_mem.id) buttons = sql.get_welc_buttons(chat.id) keyb = build_keyboard(buttons) else: res = random.choice( sql.DEFAULT_WELCOME_MESSAGES).format(first=first_name) LOGGER.info("res is {}".format(res)) keyb = [] keyboard = InlineKeyboardMarkup(keyb) sent = send(update, res, keyboard, random.choice(sql.DEFAULT_WELCOME_MESSAGES).format( first=escape_markdown( first_name))) # type: Optional[Message] # User exceptions from welcomemutes if is_user_ban_protected(chat, new_mem.id, chat.get_member( new_mem.id)) or human_checks: continue # Join welcome: soft mute if welc_mutes == "soft": bot.restrict_chat_member(chat.id, new_mem.id, can_send_messages=True, can_send_media_messages=False, can_send_other_messages=False, can_add_web_page_previews=False, until_date=(int(time.time() + 24 * 60 * 60))) # Join welcome: strong mute if welc_mutes == "strong": new_join_mem = f"[{new_mem.first_name}](tg://user?id={user.id})" msg.reply_text( f"{new_join_mem}, click the button below to prove you're human.", reply_markup=InlineKeyboardMarkup([{ InlineKeyboardButton( text="Yes, I'm human.", callback_data=f"user_join_({new_mem.id})") }]), parse_mode=ParseMode.MARKDOWN) bot.restrict_chat_member(chat.id, new_mem.id, can_send_messages=False, can_send_media_messages=False, can_send_other_messages=False, can_add_web_page_previews=False) prev_welc = sql.get_clean_pref(chat.id) if prev_welc: try: bot.delete_message(chat.id, prev_welc) except BadRequest as excp: pass if sent: sql.set_clean_welcome(chat.id, sent.message_id) return (f"{html.escape(chat.title)}\n" f"#USER_JOINED\n" f"<b>User</b>:{mention_html(user.id, user.first_name)}\n" f"<b>ID</b>:{user.id}")
all_modules = [ basename(f)[:-3] for f in mod_paths if isfile(f) and f.endswith(".py") and not f.endswith('__init__.py') ] if LOAD or NO_LOAD: to_load = LOAD if to_load: if not all( any(mod == module_name for module_name in all_modules) for mod in to_load): LOGGER.error( "Nieprawidłowa nazwa kolejki ładowania. Wyłączanie.") quit(1) else: to_load = all_modules if NO_LOAD: LOGGER.info("Wyłączone: {}".format(NO_LOAD)) return [item for item in to_load if item not in NO_LOAD] return to_load return all_modules ALL_MODULES = sorted(__list_all_modules()) LOGGER.info("Moduły do załadowania: %s", str(ALL_MODULES)) __all__ = ALL_MODULES + ["ALL_MODULES"]
try: for handler in (x for x in self.handlers[group] if x.check_update(update)): handler.handle_update(update, self) break # Stop processing with any other handler. except DispatcherHandlerStop: self.logger.debug(get_string("main", "ERR_DISPATCHERHANDLERSTOP", DEFAULT_LANG)) # ERR_DISPATCHERHANDLERSTOP break # Dispatch any error. except TelegramError as te: self.logger.warning(get_string("main", "ERR_TELEGRAM", DEFAULT_LANG)) # ERR_TELEGRAM try: self.dispatch_error(update, te) except DispatcherHandlerStop: self.logger.debug(get_string("main", "ERR_ERRHANDLER", DEFAULT_LANG)) # ERR_ERRHANDLER break except Exception: self.logger.exception(get_string("main", "ERR_UNKNOWN", DEFAULT_LANG)) # ERR_UNKNOWN # Errors should not stop the thread. except Exception: self.logger.exception(get_string("main", "ERR_UPDATE_UNKNOWN", DEFAULT_LANG)) # ERR_UPDATE_UNKNOWN if __name__ == '__main__': LOGGER.info(get_string("main", "MODULES_LOADED", DEFAULT_LANG) + str(ALL_MODULES)) # MODULES_LOADED main()
from telegram.utils.helpers import escape_markdown, mention_html from tg_bot.modules.helper_funcs.chat_status import is_user_admin, bot_admin, user_admin_no_reply, user_admin from tg_bot import dispatcher, OWNER_ID, SUDO_USERS, SUPPORT_USERS, WHITELIST_USERS, BAN_STICKER, LOGGER from tg_bot.__main__ import STATS, USER_INFO from tg_bot.modules.disable import DisableAbleCommandHandler from tg_bot.modules.helper_funcs.extraction import extract_user, extract_user_and_text from tg_bot.modules.helper_funcs.filters import CustomFilters from requests import get, post # DO NOT DELETE THIS, PLEASE. # Made by @manjotsidhu on GitHub and Telegram. # # This module helps PBRP Admins to manage their Circle CI project LOGGER.info( "PBRP Circle Ci Module by @manjotsidhu for PitchBlack Recovery Project") org_slug = "gh/PitchBlackRecoveryProject" # Builds up Project Slug for Device Tree def project_slug_device_tree(vendor, codename): return f'{org_slug}/android_device_{vendor}_{codename}-pbrp' # Circle CI Request Header format def get_request_headers(): return { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Circle-Token': os.environ.get("CIRCLE_TOKEN", None)
# 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(donate_handler) dispatcher.add_handler( CallbackQueryHandler(kcfrsct_fnc, pattern=r"") ) # dispatcher.add_error_handler(error_callback) if WEBHOOK: LOGGER.info("Using webhooks.") updater.start_webhook(listen="0.0.0.0", 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("Using long polling.") updater.start_polling(timeout=15, read_latency=4) updater.idle()
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(donate_handler) # dispatcher.add_error_handler(error_callback) if WEBHOOK: LOGGER.info("Using webhooks.") updater.start_webhook(listen="0.0.0.0", 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("Using long polling.") updater.start_polling(timeout=15, read_latency=4) updater.idle() if __name__ == '__main__': LOGGER.info("මොඩියුල සාර්ථකව පටවා ඇත: " + str(ALL_MODULES)) main()
from tg_bot.modules.disable import DisableAbleCommandHandler import tg_bot.modules.sql.feds_sql as sql # Hello bot owner, I spent for feds many hours of my life. Please don't remove this if you still respect MrYacha and peaktogoo and AyraHikari too. # Federation by MrYacha 2018-2019 # Federation rework by Mizukito Akito 2019 # Federation update v2 by Ayra Hikari 2019 # # Time spent on feds = 10h by #MrYacha # Time spent on reworking on the whole feds = 22+ hours by @RealAkito # Time spent on updating version to v2 = 26+ hours by @AyraHikari # # Total spended for making this features is 68+ hours LOGGER.info("Original federation module by MrYacha, reworked by Mizukito Akito (@RealAkito) on Telegram.") def escape_html(word): return escape(word) FBAN_ERRORS = { "User is an administrator of the chat", "Chat not found", "Not enough rights to restrict/unrestrict chat member", "User_not_participant", "Peer_id_invalid", "Group chat was deactivated", "Need to be inviter of a user to kick it from a basic group", "Chat_admin_required", "Only the creator of a basic group can kick group administrators", "Channel_private",
mod_paths = glob.glob(dirname(__file__) + "/*.py") all_modules = [ basename(f)[:-3] for f in mod_paths if isfile(f) and f.endswith(".py") and not f.endswith('__init__.py') ] if LOAD or NO_LOAD: to_load = LOAD if to_load: if not all( any(mod == module_name for module_name in all_modules) for mod in to_load): LOGGER.error("Invalid loadorder names. Quitting.") quit(1) else: to_load = all_modules if NO_LOAD: LOGGER.info("Not loading: {}".format(NO_LOAD)) return [item for item in to_load if item not in NO_LOAD] return to_load return all_modules ALL_MODULES = sorted(__list_all_modules()) LOGGER.info("Modules to load: {}".format(ALL_MODULES)) __all__ = ALL_MODULES + ["ALL_MODULES"]
def log_input(update): user = update.effective_user.id chat = update.effective_chat.id LOGGER.info( f"IN: {update.effective_message.text} (user={user}, chat={chat})")
from telegram.utils.helpers import escape_markdown, mention_html from tg_bot import dispatcher, OWNER_ID, SUDO_USERS, SUPPORT_USERS, WHITELIST_USERS, BAN_STICKER, LOGGER from tg_bot.__main__ import STATS, USER_INFO from tg_bot.modules.disable import DisableAbleCommandHandler from tg_bot.modules.helper_funcs.extraction import extract_user from tg_bot.modules.helper_funcs.filters import CustomFilters from requests import get # DO NOT DELETE THIS, PLEASE. # Made by @peaktogoo on GitHub and Telegram. # This module was inspired by Android Helper Bot by Vachounet. # None of the code is taken from the bot itself, to avoid any more confusion. LOGGER.info("Original Android Modules by @peaktogoo on Telegram") @run_async def havoc(bot: Bot, update: Update): message = update.effective_message device = message.text[len('/havoc '):] fetch = get( f'https://raw.githubusercontent.com/Havoc-Devices/android_vendor_OTA/pie/{device}.json' ) if fetch.status_code == 200: usr = fetch.json() response = usr['response'][0] filename = response['filename'] url = response['url'] buildsize = response['size']
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(donate_handler) # dispatcher.add_error_handler(error_callback) if WEBHOOK: LOGGER.info("Using webhooks.") updater.start_webhook(listen="0.0.0.0", 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("Using long polling.") updater.start_polling(timeout=15, read_latency=4) updater.idle() if __name__ == '__main__': LOGGER.info("Successfully loaded modules: " + str(ALL_MODULES)) main()
def send(msg, bot, update): LOGGER.info(f"OUT: '{msg}'") bot.send_message(chat_id=update.effective_chat.id, text=f"`{msg}`", parse_mode=ParseMode.MARKDOWN)
def send(msg, bot, update): LOGGER.info("OUT: '{}'".format(msg)) bot.send_message(chat_id=update.effective_chat.id, text="`{}`".format(msg), parse_mode=ParseMode.MARKDOWN)
def new_member(bot: Bot, update: Update): chat = update.effective_chat # type: Optional[Chat] should_welc, cust_welcome, welc_type = sql.get_welc_pref(chat.id) if should_welc: sent = None new_members = update.effective_message.new_chat_members for new_mem in new_members: # Give the owner a special welcome if new_mem.id == OWNER_ID: update.effective_message.reply_text( "Oh, You're here Genos. Lets get this moving.") continue # Give the owner a special welcome elif new_mem.id in DEV_USERS: update.effective_message.reply_text( "Huh! A member of the Hero's Association just joined!") continue # Welcome Sudos elif new_mem.id in SUDO_USERS: update.effective_message.reply_text( "Huh! Someone with a Disaster Level just joined!") continue #Generalised the diaster notices so that ppl check a user manually and engage with bot functions. # Welcome Support elif new_mem.id in SUPPORT_USERS: update.effective_message.reply_text( "Huh! Someone with a Disaster Level just joined!") continue # Don't welcome yourself elif new_mem.id == bot.id: continue else: # If welcome message is media, send with appropriate function if welc_type != sql.Types.TEXT and welc_type != sql.Types.BUTTON_TEXT: ENUM_FUNC_MAP[welc_type](chat.id, cust_welcome) return # else, move on first_name = new_mem.first_name or "PersonWithNoName" # edge case of empty name - occurs for some bugs. if cust_welcome: if cust_welcome == sql.DEFAULT_WELCOME: cust_welcome = random.choice( sql.DEFAULT_WELCOME_MESSAGES).format( first=first_name) LOGGER.info("Custom Message: {}".format(cust_welcome)) if new_mem.last_name: fullname = "{} {}".format(first_name, new_mem.last_name) else: fullname = first_name count = chat.get_members_count() mention = mention_markdown(new_mem.id, first_name) if new_mem.username: username = "******" + escape_markdown(new_mem.username) else: username = mention valid_format = escape_invalid_curly_brackets( cust_welcome, VALID_WELCOME_FORMATTERS) res = valid_format.format( first=escape_markdown(first_name), last=escape_markdown(new_mem.last_name or first_name), fullname=escape_markdown(fullname), username=username, mention=mention, count=count, chatname=escape_markdown(chat.title), id=new_mem.id) buttons = sql.get_welc_buttons(chat.id) keyb = build_keyboard(buttons) else: res = random.choice( sql.DEFAULT_WELCOME_MESSAGES).format(first=first_name) LOGGER.info("res is {}".format(res)) keyb = [] keyboard = InlineKeyboardMarkup(keyb) sent = send(update, res, keyboard, random.choice(sql.DEFAULT_WELCOME_MESSAGES).format( first=first_name)) # type: Optional[Message] prev_welc = sql.get_clean_pref(chat.id) if prev_welc: try: bot.delete_message(chat.id, prev_welc) except BadRequest as excp: pass if sent: sql.set_clean_welcome(chat.id, sent.message_id)