def _message(func): try: if can_disable: self._dispatcher.add_handler( DisableAbleMessageHandler(pattern, func, friendly=friendly, run_async=run_async), group) else: self._dispatcher.add_handler( MessageHandler(pattern, func, run_async=run_async), group) log.info( f"[KIGMSG] Loaded filter pattern {pattern} for function {func.__name__} in group {group}" ) except TypeError: if can_disable: self._dispatcher.add_handler( DisableAbleMessageHandler(pattern, func, friendly=friendly, run_async=run_async)) else: self._dispatcher.add_handler( MessageHandler(pattern, func, run_async=run_async)) log.info( f"[KIGMSG] Loaded filter pattern {pattern} for function {func.__name__}" ) return func
def shell(update: Update, context: CallbackContext): message = update.effective_message cmd = message.text.split(" ", 1) if len(cmd) == 1: message.reply_text("No command to execute was given.") return cmd = cmd[1] process = subprocess.Popen( cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True, ) stdout, stderr = process.communicate() reply = "" stderr = stderr.decode() stdout = stdout.decode() if stdout: reply += f"*Stdout*\n`{stdout}`\n" LOGGER.info(f"Shell - {cmd} - {stdout}") if stderr: reply += f"*Stderr*\n`{stderr}`\n" LOGGER.error(f"Shell - {cmd} - {stderr}") if len(reply) > 3000: with open("shell_output.txt", "w") as file: file.write(reply) with open("shell_output.txt", "rb") as doc: context.bot.send_document( document=doc, filename=doc.name, reply_to_message_id=message.message_id, chat_id=message.chat_id, ) else: message.reply_text(reply, parse_mode=ParseMode.MARKDOWN)
def main(): """#TODO""" test_handler = CommandHandler("test", test, run_async=True) start_handler = CommandHandler("start", start, pass_args=True, run_async=True) help_handler = CommandHandler("help", get_help, run_async=True) help_callback_handler = CallbackQueryHandler(help_button, pattern=r"help_", run_async=True) settings_handler = CommandHandler("settings", get_settings, run_async=True) settings_callback_handler = CallbackQueryHandler(settings_button, pattern=r"stngs_", run_async=True) donate_handler = DisableAbleCommandHandler("donate", donate, run_async=True) migrate_handler = MessageHandler(Filters.status_update.migrate, migrate_chats, run_async=True) # 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_error_handler(error_callback) # dispatcher.add_error_handler(error_handler) if WEBHOOK: log.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: log.info( f"Yuii started, Using long polling. | BOT: [@{dispatcher.bot.username}]" ) updater.start_polling(allowed_updates=Update.ALL_TYPES, timeout=15, read_latency=4, drop_pending_updates=True) if len(argv) not in (1, 3, 4): telethn.disconnect() else: telethn.run_until_disconnected() updater.idle()
def main(): dispatcher.add_error_handler(error_callback) # dispatcher.add_error_handler(error_handler) if WEBHOOK: log.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: log.info( f"Tedeza started, Using long polling. | BOT: [@{dispatcher.bot.username}]" ) KigyoINIT.bot_id = dispatcher.bot.id KigyoINIT.bot_username = dispatcher.bot.username KigyoINIT.bot_name = dispatcher.bot.first_name updater.start_polling(timeout=15, read_latency=4, drop_pending_updates=True) if len(argv) not in (1, 3, 4): telethn.disconnect() else: telethn.run_until_disconnected() updater.idle()
def main(): test_handler = CommandHandler("test", test, run_async=True) start_handler = CommandHandler("start", start, pass_args=True, run_async=True) help_handler = CommandHandler("help", get_help, run_async=True) help_callback_handler = CallbackQueryHandler( help_button, pattern=r"help_", run_async=True ) settings_handler = CommandHandler("settings", get_settings, run_async=True) settings_callback_handler = CallbackQueryHandler( settings_button, pattern=r"stngs_", run_async=True ) donate_handler = DisableAbleCommandHandler("donate", donate, run_async=True) migrate_handler = MessageHandler( Filters.status_update.migrate, migrate_chats, run_async=True ) # 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_error_handler(error_callback) _message_queue = messagequeue.MessageQueue(autostart=False) # dispatcher.add_error_handler(error_handler) if WEBHOOK: log.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: log.info("Using long polling.") _message_queue.start() updater.start_polling(timeout=15, read_latency=4, clean=True) if len(argv) not in (1, 3, 4): telethn.disconnect() else: telethn.run_until_disconnected() updater.idle() _message_queue.stop() def start_updater(poll_interval, timeout): self.updater.start_polling(poll_interval=poll_interval, timeout=timeout) self.updater.idle() args = (0.1, 10) self.updater_thread = threading.Thread(target=start_updater, args=args) self.updater_thread.daemon = True self.updater_thread.start() while(True): pass
def migrate_chats(update: Update, context: CallbackContext): """#TODO Params: update: Update - context: CallbackContext - """ 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 log.info("Migrating from %s, to %s", str(old_chat), str(new_chat)) for mod in MIGRATEABLE: try: mod.__migrate__(old_chat, new_chat) except: pass log.info("Successfully migrated!") raise DispatcherHandlerStop
def __list_all_modules(): from os.path import dirname, basename, isfile import glob # This generates a list of modules in this folder for the * in __main__ to work. 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): log.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: log.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
def check_and_ban(update, user_id, should_message=True): from tg_bot import SPB_MODE chat = update.effective_chat # type: Optional[Chat] if SPB_MODE: try: apst = requests.get( f'https://api.intellivoid.net/spamprotection/v1/lookup?query={update.effective_user.id}') api_status = apst.status_code if api_status == 200: try: status = client.raw_output(int(user_id)) try: bl_check = (status["results"]["attributes"]["is_blacklisted"]) except: bl_check = False if bl_check: bl_res = (status["results"]["attributes"]["blacklist_reason"]) update.effective_chat.kick_member(user_id) if should_message: update.effective_message.reply_text( f"This person was blacklisted on @SpamProtectionBot and has been removed!\nReason: <code>{bl_res}</code>", parse_mode=ParseMode.HTML, ) except HostDownError: log.warning("Spam Protection API is unreachable.") except BaseException as e: log.info(f'SpamProtection was disabled due to {e}') try: sw_ban = sw.get_ban(int(user_id)) except AttributeError: sw_ban = None except (SpamWatchError, Error, UnauthorizedError, NotFoundError, Forbidden, TooManyRequests) as e: log.warning(f" SpamWatch Error: {e}") sw_ban = None if sw_ban: update.effective_chat.kick_member(user_id) if should_message: update.effective_message.reply_text( f"This person has been detected as a spammer by @SpamWatch and has been removed!\nReason: <code>{sw_ban.reason}</code>", parse_mode=ParseMode.HTML, ) return if sql.is_user_gbanned(user_id): update.effective_chat.kick_member(user_id) if should_message: text = ( f"<b>Alert</b>: this user is globally banned.\n" f"<code>*bans them from here*</code>.\n" f"<b>Appeal chat</b>: @zerounions\n" f"<b>User ID</b>: <code>{user_id}</code>" ) user = sql.get_gbanned_user(user_id) if user.reason: text += f"\n<b>Ban Reason:</b> <code>{html.escape(user.reason)}</code>" update.effective_message.reply_text(text, parse_mode=ParseMode.HTML)
def _callbackquery(func): self._dispatcher.add_handler( CallbackQueryHandler(pattern=pattern, callback=func, run_async=run_async)) log.info( f'[KIGCALLBACK] Loaded callbackquery handler with pattern {pattern} for function {func.__name__}' ) return func
def _inlinequery(func): self._dispatcher.add_handler( InlineQueryHandler(pattern=pattern, callback=func, run_async=run_async, pass_user_data=pass_user_data, pass_chat_data=pass_chat_data, chat_types=chat_types)) log.info( f'[KIGINLINE] Loaded inlinequery handler with pattern {pattern} for function {func.__name__} | PASSES USER DATA: {pass_user_data} | PASSES CHAT DATA: {pass_chat_data} | CHAT TYPES: {chat_types}' ) return func
def send(msg, bot, update): if len(str(msg)) > 2000: with io.BytesIO(str.encode(msg)) as out_file: out_file.name = "output.txt" bot.send_document(chat_id=update.effective_chat.id, document=out_file) else: LOGGER.info(f"OUT: '{msg}'") bot.send_message( chat_id=update.effective_chat.id, text=f"`{msg}`", parse_mode=ParseMode.MARKDOWN, )
def _command(func): try: if can_disable: self._dispatcher.add_handler( DisableAbleCommandHandler(command, func, filters=filters, run_async=run_async, pass_args=pass_args, admin_ok=admin_ok), group) else: self._dispatcher.add_handler( CommandHandler(command, func, filters=filters, run_async=run_async, pass_args=pass_args), group) log.info( f"[KIGCMD] Loaded handler {command} for function {func.__name__} in group {group}" ) except TypeError: if can_disable: self._dispatcher.add_handler( DisableAbleCommandHandler( command, func, filters=filters, run_async=run_async, pass_args=pass_args, admin_ok=admin_ok, pass_chat_data=pass_chat_data)) else: self._dispatcher.add_handler( CommandHandler(command, func, filters=filters, run_async=run_async, pass_args=pass_args, pass_chat_data=pass_chat_data)) log.info( f"[KIGCMD] Loaded handler {command} for function {func.__name__}" ) return func
def start() -> scoped_session: engine = create_engine(DB_URI, client_encoding="utf8") log.info("[PostgreSQL] Connecting to database......") BASE.metadata.bind = engine BASE.metadata.create_all(engine) return scoped_session(sessionmaker(bind=engine, autoflush=False))
from sqlalchemy import create_engine from sqlalchemy.ext.declarative import declarative_base from sqlalchemy.orm import sessionmaker, scoped_session from tg_bot import DB_URI, log def start() -> scoped_session: engine = create_engine(DB_URI, client_encoding="utf8") log.info("[PostgreSQL] Connecting to database......") BASE.metadata.bind = engine BASE.metadata.create_all(engine) return scoped_session(sessionmaker(bind=engine, autoflush=False)) BASE = declarative_base() SESSION = start() log.info("[PostgreSQL] Connection successful, session started.")
def inlineinfo(query: str, update: Update, context: CallbackContext) -> None: """Handle the inline query.""" bot = context.bot query = update.inline_query.query log.info(query) user_id = update.effective_user.id try: search = query.split(" ", 1)[1] except IndexError: search = user_id try: user = bot.get_chat(int(search)) except (BadRequest, ValueError): user = bot.get_chat(user_id) chat = update.effective_chat sql.update_user(user.id, user.username) text = (f"<b>Information:</b>\n" f"• ID: <code>{user.id}</code>\n" f"• First Name: {html.escape(user.first_name)}") if user.last_name: text += f"\n• Last Name: {html.escape(user.last_name)}" if user.username: text += f"\n• Username: @{html.escape(user.username)}" text += f"\n• Permanent user link: {mention_html(user.id, 'link')}" nation_level_present = False if user.id == OWNER_ID: text += f"\n\nThis person is my owner" nation_level_present = True elif user.id in DEV_USERS: text += f"\n\nThis Person is a part of Eagle Union" nation_level_present = True elif user.id in SUDO_USERS: text += f"\n\nThe Nation level of this person is Royal" nation_level_present = True elif user.id in SUPPORT_USERS: text += f"\n\nThe Nation level of this person is Sakura" nation_level_present = True elif user.id in SARDEGNA_USERS: text += f"\n\nThe Nation level of this person is Sardegna" nation_level_present = True elif user.id in WHITELIST_USERS: text += f"\n\nThe Nation level of this person is Neptunia" nation_level_present = True if nation_level_present: text += ' [<a href="https://t.me/{}?start=nations">?</a>]'.format( bot.username) try: spamwtc = sw.get_ban(int(user.id)) if spamwtc: text += "<b>\n\n• SpamWatched:\n</b> Yes" text += f"\n• Reason: <pre>{spamwtc.reason}</pre>" text += "\n• Appeal at @SpamWatchSupport" else: text += "<b>\n\n• SpamWatched:</b> No" except: pass # don't crash if api is down somehow... num_chats = sql.get_user_num_chats(user.id) text += f"\n• <b>Chat count</b>: <code>{num_chats}</code>" kb = InlineKeyboardMarkup([ [ InlineKeyboardButton( text="Report Error", url=f"https://t.me/YorktownEagleUnion", ), InlineKeyboardButton( text="Search again", switch_inline_query_current_chat=".info ", ), ], ]) results = [ InlineQueryResultArticle( id=str(uuid4()), title=f"User info of {html.escape(user.first_name)}", input_message_content=InputTextMessageContent( text, parse_mode=ParseMode.HTML, disable_web_page_preview=True), reply_markup=kb), ] update.inline_query.answer(results, cache_time=5)
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})")
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): log.error("[NOBARA] 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: log.info("[NOBARA] 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() log.info("[NOBARA] Modules to load: %s", str(ALL_MODULES)) __all__ = ALL_MODULES + ["ALL_MODULES"]
def inlineinfo(query: str, update: Update, context: CallbackContext) -> None: """Handle the inline query.""" bot = context.bot query = update.inline_query.query log.info(query) user_id = update.effective_user.id try: search = query.split(" ", 1)[1] except IndexError: search = user_id try: user = bot.get_chat(int(search)) except (BadRequest, ValueError): user = bot.get_chat(user_id) chat = update.effective_chat sql.update_user(user.id, user.username) text = (f"<b>Information:</b>\n" f"• ID: <code>{user.id}</code>\n" f"• First Name: {html.escape(user.first_name)}") if user.last_name: text += f"\n• Last Name: {html.escape(user.last_name)}" if user.username: text += f"\n• Username: @{html.escape(user.username)}" text += f"\n• Permanent user link: {mention_html(user.id, 'link')}" nation_level_present = False if user.id == OWNER_ID: text += f"\n\nThis person is my owner" nation_level_present = True elif user.id in DEV_USERS: text += f"\n\nThis Person is a part of Eagle Union" nation_level_present = True elif user.id in SUDO_USERS: text += f"\n\nThe Nation level of this person is Royal" nation_level_present = True elif user.id in SUPPORT_USERS: text += f"\n\nThe Nation level of this person is Sakura" nation_level_present = True elif user.id in SARDEGNA_USERS: text += f"\n\nThe Nation level of this person is Sardegna" nation_level_present = True elif user.id in WHITELIST_USERS: text += f"\n\nThe Nation level of this person is Neptunia" nation_level_present = True if nation_level_present: text += ' [<a href="https://t.me/{}?start=nations">?</a>]'.format( bot.username) try: spamwtc = sw.get_ban(int(user.id)) if spamwtc: text += "<b>\n\n• SpamWatched:\n</b> Yes" text += f"\n• Reason: <pre>{spamwtc.reason}</pre>" text += "\n• Appeal at @SpamWatchSupport" else: text += "<b>\n\n• SpamWatched:</b> No" except: pass # don't crash if api is down somehow... apst = requests.get( f'https://api.intellivoid.net/spamprotection/v1/lookup?query={context.bot.username}' ) api_status = apst.status_code if (api_status == 200): try: status = client.raw_output(int(user.id)) # ptid = status["results"]["private_telegram_id"] op = status["results"]["attributes"]["is_operator"] ag = status["results"]["attributes"]["is_agent"] wl = status["results"]["attributes"]["is_whitelisted"] ps = status["results"]["attributes"]["is_potential_spammer"] sp = status["results"]["spam_prediction"]["spam_prediction"] hamp = status["results"]["spam_prediction"]["ham_prediction"] blc = status["results"]["attributes"]["is_blacklisted"] if blc: blres = status["results"]["attributes"]["blacklist_reason"] else: blres = None text += "\n\n<b>SpamProtection:</b>" # text += f"<b>\n• Private Telegram ID:</b> <code>{ptid}</code>\n" text += f"<b>\n• Operator:</b> <code>{op}</code>\n" text += f"<b>• Agent:</b> <code>{ag}</code>\n" text += f"<b>• Whitelisted:</b> <code>{wl}</code>\n" text += f"<b>• Spam/Ham Prediction:</b> <code>{round((sp/hamp*100), 3)}%</code>\n" text += f"<b>• Potential Spammer:</b> <code>{ps}</code>\n" text += f"<b>• Blacklisted:</b> <code>{blc}</code>\n" text += f"<b>• Blacklist Reason:</b> <code>{blres}</code>\n" except HostDownError: text += "\n\n<b>SpamProtection:</b>" text += "\nCan't connect to Intellivoid SpamProtection API\n" else: text += "\n\n<b>SpamProtection:</b>" text += f"\n<code>API RETURNED: {api_status}</code>\n" num_chats = sql.get_user_num_chats(user.id) text += f"\n• Chat count: <code>{num_chats}</code>" kb = InlineKeyboardMarkup([ [ InlineKeyboardButton( text="Report Error", url=f"https://t.me/YorktownEagleUnion", ), InlineKeyboardButton( text="Search again", switch_inline_query_current_chat=".info ", ), ], ]) results = [ InlineQueryResultArticle( id=str(uuid4()), title=f"User info of {html.escape(user.first_name)}", input_message_content=InputTextMessageContent( text, parse_mode=ParseMode.HTML, disable_web_page_preview=True), reply_markup=kb), ] update.inline_query.answer(results, cache_time=5)
if WEBHOOK: log.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: log.info( f"Nobara started, Using long polling. | BOT: [@{dispatcher.bot.username}]" ) updater.start_polling(timeout=15, read_latency=4, drop_pending_updates=True) if len(argv) not in (1, 3, 4): telethn.disconnect() else: telethn.run_until_disconnected() updater.idle() if __name__ == "__main__": kp.start() log.info("[KUGISAKI] Successfully loaded modules: " + str(ALL_MODULES)) telethn.start(bot_token=TOKEN) main() idle()
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): log.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: log.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() log.info("Modules to load: %s", str(ALL_MODULES)) __all__ = ALL_MODULES + ["ALL_MODULES"]
def inlineinfo(query: str, update: Update, context: CallbackContext) -> None: """Handle the inline query.""" bot = context.bot query = update.inline_query.query log.info(query) user_id = update.effective_user.id try: search = query.split(" ", 1)[1] except IndexError: search = user_id try: user = bot.get_chat(int(search)) except (BadRequest, ValueError): user = bot.get_chat(user_id) chat = update.effective_chat sql.update_user(user.id, user.username) text = (f"<b>General:</b>\n" f"ID: <code>{user.id}</code>\n" f"First Name: {html.escape(user.first_name)}") if user.last_name: text += f"\nLast Name: {html.escape(user.last_name)}" if user.username: text += f"\nUsername: @{html.escape(user.username)}" text += f"\nPermanent user link: {mention_html(user.id, 'link')}" try: spamwtc = sw.get_ban(int(user.id)) if spamwtc: text += "<b>\n\nSpamWatch:\n</b>" text += "<b>This person is banned in Spamwatch!</b>" text += f"\nReason: <pre>{spamwtc.reason}</pre>" text += "\nAppeal at @SpamWatchSupport" else: text += "<b>\n\nSpamWatch:</b>\n Not banned" except: pass # don't crash if api is down somehow... try: status = client.raw_output(int(user.id)) ptid = status["results"]["private_telegram_id"] op = status["results"]["attributes"]["is_operator"] ag = status["results"]["attributes"]["is_agent"] wl = status["results"]["attributes"]["is_whitelisted"] ps = status["results"]["attributes"]["is_potential_spammer"] sp = status["results"]["spam_prediction"]["spam_prediction"] hamp = status["results"]["spam_prediction"]["ham_prediction"] blc = status["results"]["attributes"]["is_blacklisted"] if blc: blres = status["results"]["attributes"]["blacklist_reason"] else: blres = None text += "\n\n<b>SpamProtection:</b>" text += f"<b>\nPrivate Telegram ID:</b> <code>{ptid}</code>\n" text += f"<b>Operator:</b> <code>{op}</code>\n" text += f"<b>Agent:</b> <code>{ag}</code>\n" text += f"<b>Whitelisted:</b> <code>{wl}</code>\n" text += f"<b>Spam Prediction:</b> <code>{sp}</code>\n" text += f"<b>Ham Prediction:</b> <code>{hamp}</code>\n" text += f"<b>Potential Spammer:</b> <code>{ps}</code>\n" text += f"<b>Blacklisted:</b> <code>{blc}</code>\n" text += f"<b>Blacklist Reason:</b> <code>{blres}</code>\n" except HostDownError: text += "\n\n<b>SpamProtection:</b>" text += "\nCan't connect to Intellivoid SpamProtection API\n" nation_level_present = False num_chats = sql.get_user_num_chats(user.id) text += f"\nChat count: <code>{num_chats}</code>" if user.id == OWNER_ID: text += f"\nThis person is my owner" nation_level_present = True elif user.id in DEV_USERS: text += f"\nThis Person is a part of Eagle Union" nation_level_present = True elif user.id in SUDO_USERS: text += f"\nThe Nation level of this person is Royal" nation_level_present = True elif user.id in SUPPORT_USERS: text += f"\nThe Nation level of this person is Sakura" nation_level_present = True elif user.id in SARDEGNA_USERS: text += f"\nThe Nation level of this person is Sardegna" nation_level_present = True elif user.id in WHITELIST_USERS: text += f"\nThe Nation level of this person is Neptunia" nation_level_present = True if nation_level_present: text += ' [<a href="https://t.me/{}?start=nations">?</a>]'.format( bot.username) results = [ InlineQueryResultArticle( id=str(uuid4()), title=f"User info of {html.escape(user.first_name)}", input_message_content=InputTextMessageContent( text, parse_mode=ParseMode.HTML, disable_web_page_preview=True), ), ] update.inline_query.answer(results, cache_time=5)
if WEBHOOK: log.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: log.info( f"Kigyo started, Using long polling. | BOT: [@{dispatcher.bot.username}]" ) updater.start_polling(timeout=15, read_latency=4, drop_pending_updates=True) if len(argv) not in (1, 3, 4): telethn.disconnect() else: telethn.run_until_disconnected() updater.idle() if __name__ == "__main__": kp.start() log.info("[KIGYO] Successfully loaded modules: " + str(ALL_MODULES)) telethn.start(bot_token=TOKEN) main() idle()
] 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 ): log.error("[KIGYO] 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: log.info("[KIGYO] 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() log.info("[KIGYO] Modules to load: %s", str(ALL_MODULES)) __all__ = ALL_MODULES + ["ALL_MODULES"]