def press_button_await( self, pattern, filters=None, num_expected=None, raise_=True, quote=False, ): button = self.find_button(pattern) if filters: filters = filters & Filters.chat(self._peer_id) else: filters = Filters.chat(self._peer_id) filters = filters & (Filters.text | Filters.edited) action = AwaitableAction( func=self._client.send_message, args=(self._peer_id, button), kwargs=dict( reply_to_message_id=self._message_id if quote else None), filters=filters, num_expected=num_expected, ) return self._client.act_await_response(action, raise_=raise_)
def start(self): self.bot.add_handler(MessageHandler(self.handle_start, Filters.command('start') & Filters.private)) self.bot.add_handler(MessageHandler(self.handle_create, Filters.command('create',) & Filters.private)) self.bot.add_handler(MessageHandler(self.handle_cancel, Filters.command('cancel') & Filters.private)) self.bot.add_handler(MessageHandler(self.handle_list, Filters.command('list') & Filters.private)) self.bot.add_handler(MessageHandler(self.handle_close, Filters.command('close') & Filters.private)) self.bot.add_handler(MessageHandler(self.handle_reply, Filters.reply & Filters.text & Filters.private)) self.bot.add_handler(MessageHandler(self.handle_msg, Filters.text & Filters.private)) self.bot.add_handler(MessageHandler(self.call_superuser_function, Filters.chat(self.help_group) & Filters.reply & Filters.command('m'))) self.bot.add_handler(MessageHandler(self.handle_group, Filters.reply & Filters.chat(self.help_group))) self.bot.add_handler(MessageHandler(self.handle_manual_add_blacklist, Filters.command('a') & Filters.chat(self.help_group))) self.bot.add_handler(MessageHandler(self.handle_other, Filters.private)) self.bot.add_handler(CallbackQueryHandler(self.answer)) return self.bot.start()
async def main(): msg_ids = {} app = Client("ssn", 950979, "e3135b7af1cd3681d5e9bad56591ff65") d = -1001421693753 s = -1001100924541 @app.on_message(Filters.chat(s) & Filters.text & ~Filters.edited) def forward(client, Message): words = [ 'dekho', 'TRUST', 'join', 'fix', '😱', '😳', '👆', '👇', '☝️', 'https://', '😂', '🤔', 'pass', 'chase', 'link', 'suno', 'member', '❓', 'loss', 'audio', 'open', "report", 'paid', 'contact', 'baazigar', 'market', 'load', 'whatsapp', 'book', 'bhai', '🐴', 'only', 'chut', 'tennis', 'teen', 'lavde', 'chutiya', 'bc', 'kya', 'LUND', 'WICKET LU', '?', 'loda', 'telegram', 'chor', "kama", "lakh", ' id', 'स', "kitna" ] for word in words: if word.casefold() in Message.text.casefold(): return z = client.send_message(d, "<b> " + Message.text.replace("🖲", "🙇🏼♂").replace( "📟", "🎳").replace("🇩🇪", "🇮🇶") + " </b>", parse_mode="html").message_id msg_ids[Message.message_id] = z @app.on_message(Filters.chat(s) & Filters.text & Filters.edited) def forward(client, Message): if not Message.message_id in msg_ids: return try: client.edit_message_text( d, msg_ids[Message.message_id], "<b>" + Message.text.replace("🖲", "🙇🏼♂").replace( "📟", "🎳").replace("🇩🇪", "🇮🇶") + " </b>", parse_mode="html") except FloodWait as e: time.sleep(e.x) @app.on_deleted_messages(Filters.chat(s)) def main(client, messages): for Message in messages: if not Message.message_id in msg_ids: return client.delete_messages(d, msg_ids[Message.message_id]) app.run()
async def ping_bot( self, bot, override_messages=None, max_wait_response=None, min_wait_consecutive=None, raise_=True ): messages = ["/start"] if override_messages: messages = override_messages async def send_pings(): for n, m in enumerate(messages): try: if n >= 1: await asyncio.sleep(1) self.send_message(bot, m) except FloodWait as e: if e.x > 5: self.logger.warning("send_message flood: waiting {} seconds".format(e.x)) time.sleep(e.x) continue action = AwaitableAction( send_pings, filters=Filters.chat(bot), max_wait=max_wait_response, min_wait_consecutive=min_wait_consecutive, ) return await self.act_await_response(action, raise_=raise_)
def ping_bot( self, bot: Union[int, str], override_messages: List[str] = None, max_wait_response: float = None, min_wait_consecutive: float = None, ) -> Union[Response, bool]: messages = ["/start"] if override_messages: messages = override_messages def send_pings(): for n, m in enumerate(messages): try: if n >= 1: time.sleep(1) self.send_message(bot, m) except FloodWait as e: if e.x > 5: self.logger.warning( "send_message flood: waiting {} seconds".format( e.x)) time.sleep(e.x) continue action = AwaitableAction( send_pings, filters=Filters.chat(bot), max_wait=max_wait_response, min_wait_consecutive=min_wait_consecutive, ) return self.act_await_response(action)
class Config: """ Configs to setup Userge. """ API_ID = int(os.environ.get("API_ID", 12345)) API_HASH = os.environ.get("API_HASH", None) HU_STRING_SESSION = os.environ.get("HU_STRING_SESSION", None) DB_URI = os.environ.get("DATABASE_URL", None) MAX_MESSAGE_LENGTH = 4096 LANG = os.environ.get("PREFERRED_LANGUAGE", "en") DOWN_PATH = os.environ.get("DOWN_PATH", "downloads/") SCREENSHOT_API = os.environ.get("SCREENSHOT_API", None) CURRENCY_API = os.environ.get("CURRENCY_API", None) G_DRIVE_CLIENT_ID = os.environ.get("G_DRIVE_CLIENT_ID", None) G_DRIVE_CLIENT_SECRET = os.environ.get("G_DRIVE_CLIENT_SECRET", None) G_DRIVE_PARENT_ID = os.environ.get("G_DRIVE_PARENT_ID", None) G_DRIVE_IS_TD = bool(os.environ.get("G_DRIVE_IS_TD", False)) LOG_CHANNEL_ID = int(os.environ.get("LOG_CHANNEL_ID", 0)) UPSTREAM_REPO = os.environ.get("UPSTREAM_REPO", "https://github.com/UsergeTeam/Userge") HEROKU_API_KEY = os.environ.get("HEROKU_API_KEY", None) HEROKU_APP_NAME = os.environ.get("HEROKU_APP_NAME", None) HEROKU_APP = None HEROKU_GIT_URL = None PUSHING = False MSG_DELETE_TIMEOUT = 120 WELCOME_DELETE_TIMEOUT = 120 ALLOWED_CHATS = Filters.chat([]) SUDO_TRIGGER = os.environ.get("SUDO_TRIGGER", '!') SUDO_USERS: Set[int] = set() ALLOWED_COMMANDS: Set[str] = set()
def start(self): self.app.add_handler( MessageHandler( self.handle_edit, Filters.chat(self.target_group) & ~Filters.user(self.bot_id) & Filters.edited)) self.app.add_handler( MessageHandler( self.handle_new_member, Filters.chat(self.target_group) & Filters.new_chat_members)) self.app.add_handler( MessageHandler( self.handle_document, Filters.chat(self.target_group) & ~Filters.user(self.bot_id) & Filters.document)) self.app.add_handler( MessageHandler( self.handle_photo, Filters.chat(self.target_group) & ~Filters.user(self.bot_id) & Filters.photo)) self.app.add_handler( MessageHandler( self.handle_sticker, Filters.chat(self.target_group) & ~Filters.user(self.bot_id) & Filters.sticker)) self.app.add_handler( MessageHandler( self.handle_gif, Filters.chat(self.target_group) & ~Filters.user(self.bot_id) & Filters.animation)) self.app.add_handler( MessageHandler( self.handle_video, Filters.chat(self.target_group) & ~Filters.user(self.bot_id) & Filters.video)) self.app.add_handler( MessageHandler( self.handle_speak, Filters.chat(self.target_group) & ~Filters.user(self.bot_id) & Filters.text)) self.app.add_handler( MessageHandler(self.handle_incoming, Filters.incoming & Filters.chat(self.fudu_group))) self.botapp.add_handler(CallbackQueryHandler(self.handle_callback)) self.join_group_verify.init() self.app.start() self.botapp.start() self.init() self.custom_service.start()
def run(self): @self.telegram_client.on_message( Filters.chat(self.chat_id) & Filters.photo & Filters.caption) def echoPT(client, message): translation = self.translate(message.caption) self.send_photo(message.photo.file_id, translation) @self.telegram_client.on_message( Filters.chat(self.chat_id) & Filters.photo & ~Filters.caption) def echoP(client, message): self.send_photo(message.photo.file_id) @self.telegram_client.on_message( Filters.chat(self.chat_id) & Filters.text & ~Filters.photo) def echoT(client, message): translation = self.translate(message.text) if translation: self.send_text(translation) self.telegram_client.run()
def __init__(self, tg_config, tg_queue): self.session = Client("my_session", tg_config['api_id'], tg_config['api_hash']) @self.session.on_message( Filters.chat(tg_config['chat_id']) & Filters.text) def echo(self, message): if message.text.startswith("🍏") or message.text.startswith("🍇"): tg_queue.put({'text': message.text, 'date': message.date}) else: pass
class Config: """ Configs to setup Userge """ API_ID = int(os.environ.get("API_ID")) API_HASH = os.environ.get("API_HASH") WORKERS = int(os.environ.get("WORKERS")) BOT_TOKEN = os.environ.get("BOT_TOKEN", None) HU_STRING_SESSION = os.environ.get("HU_STRING_SESSION", None) OWNER_ID = int(os.environ.get("OWNER_ID", 0)) LOG_CHANNEL_ID = int(os.environ.get("LOG_CHANNEL_ID")) DB_URI = os.environ.get("DATABASE_URL") LANG = os.environ.get("PREFERRED_LANGUAGE") DOWN_PATH = os.environ.get("DOWN_PATH") CMD_TRIGGER = os.environ.get("CMD_TRIGGER") SUDO_TRIGGER = os.environ.get("SUDO_TRIGGER") FINISHED_PROGRESS_STR = os.environ.get("FINISHED_PROGRESS_STR") UNFINISHED_PROGRESS_STR = os.environ.get("UNFINISHED_PROGRESS_STR") UPSTREAM_REPO = os.environ.get("UPSTREAM_REPO") UPSTREAM_REMOTE = os.environ.get("UPSTREAM_REMOTE") SCREENSHOT_API = os.environ.get("SCREENSHOT_API", None) SPAM_WATCH_API = os.environ.get("SPAM_WATCH_API", None) CURRENCY_API = os.environ.get("CURRENCY_API", None) OCR_SPACE_API_KEY = os.environ.get("OCR_SPACE_API_KEY", None) OPEN_WEATHER_MAP = os.environ.get("OPEN_WEATHER_MAP", None) REMOVE_BG_API_KEY = os.environ.get("REMOVE_BG_API_KEY", None) WEATHER_DEFCITY = os.environ.get("WEATHER_DEFCITY", None) TZ_NUMBER = os.environ.get("TZ_NUMBER", 1) G_DRIVE_CLIENT_ID = os.environ.get("G_DRIVE_CLIENT_ID", None) G_DRIVE_CLIENT_SECRET = os.environ.get("G_DRIVE_CLIENT_SECRET", None) G_DRIVE_PARENT_ID = os.environ.get("G_DRIVE_PARENT_ID", None) G_DRIVE_INDEX_LINK = os.environ.get("G_DRIVE_INDEX_LINK", None) GOOGLE_CHROME_DRIVER = os.environ.get("GOOGLE_CHROME_DRIVER", None) GOOGLE_CHROME_BIN = os.environ.get("GOOGLE_CHROME_BIN", None) HEROKU_API_KEY = os.environ.get("HEROKU_API_KEY", None) HEROKU_APP_NAME = os.environ.get("HEROKU_APP_NAME", None) HEROKU_GIT_URL = os.environ.get("HEROKU_GIT_URL", None) G_DRIVE_IS_TD = os.environ.get("G_DRIVE_IS_TD") == "true" ANTISPAM_SENTRY = os.environ.get("ANTISPAM_SENTRY") == "true" LOAD_UNOFFICIAL_PLUGINS = os.environ.get( "LOAD_UNOFFICIAL_PLUGINS") == "true" TMP_PATH = "userge/plugins/temp/" MAX_MESSAGE_LENGTH = 4096 MSG_DELETE_TIMEOUT = 120 WELCOME_DELETE_TIMEOUT = 120 AUTOPIC_TIMEOUT = 300 ALLOWED_CHATS = Filters.chat([]) ALLOW_ALL_PMS = True USE_USER_FOR_CLIENT_CHECKS = False SUDO_USERS: Set[int] = set() ALLOWED_COMMANDS: Set[str] = set() HEROKU_APP = None
class Config: """Configs to setup Userge""" API_ID = int(os.environ.get("API_ID", 12345)) API_HASH = os.environ.get("API_HASH", None) ANTISPAM_SENTRY = bool(os.environ.get("ANTISPAM_SENTRY", False)) HU_STRING_SESSION = os.environ.get("HU_STRING_SESSION", None) DB_URI = os.environ.get("DATABASE_URL", None) LANG = os.environ.get("PREFERRED_LANGUAGE", "en") DOWN_PATH = os.environ.get("DOWN_PATH", "downloads").rstrip('/') + '/' SCREENSHOT_API = os.environ.get("SCREENSHOT_API", None) SPAM_WATCH_API = os.environ.get("SPAM_WATCH_API", None) CURRENCY_API = os.environ.get("CURRENCY_API", None) OCR_SPACE_API_KEY = os.environ.get("OCR_SPACE_API_KEY", None) OPEN_WEATHER_MAP = os.environ.get("OPEN_WEATHER_MAP", None) REMOVE_BG_API_KEY = os.environ.get("REMOVE_BG_API_KEY", None) WEATHER_DEFCITY = os.environ.get("WEATHER_DEFCITY", None) ARL_TOKEN = os.environ.get("ARL_TOKEN", None) TZ_NUMBER = os.environ.get("TZ_NUMBER", 1) G_DRIVE_CLIENT_ID = os.environ.get("G_DRIVE_CLIENT_ID", None) G_DRIVE_CLIENT_SECRET = os.environ.get("G_DRIVE_CLIENT_SECRET", None) G_DRIVE_PARENT_ID = os.environ.get("G_DRIVE_PARENT_ID", None) G_DRIVE_IS_TD = bool(os.environ.get("G_DRIVE_IS_TD", False)) GOOGLE_CHROME_DRIVER = os.environ.get("GOOGLE_CHROME_DRIVER", None) GOOGLE_CHROME_BIN = os.environ.get("GOOGLE_CHROME_BIN", None) LOG_CHANNEL_ID = int(os.environ.get("LOG_CHANNEL_ID", 0)) UPSTREAM_REPO = os.environ.get("UPSTREAM_REPO", "https://github.com/rzlamrr/UsergeX") HEROKU_API_KEY = os.environ.get("HEROKU_API_KEY", None) HEROKU_APP_NAME = os.environ.get("HEROKU_APP_NAME", None) HEROKU_GIT_URL = os.environ.get("HEROKU_GIT_URL", None) LOAD_UNOFFICIAL_PLUGINS = bool(os.environ.get("LOAD_UNOFFICIAL_PLUGINS", False)) CMD_TRIGGER = os.environ.get("CMD_TRIGGER", '.') SUDO_TRIGGER = os.environ.get("SUDO_TRIGGER", '!') FINISHED_PROGRESS_STR = os.environ.get("FINISHED_PROGRESS_STR", '█') UNFINISHED_PROGRESS_STR = os.environ.get("UNFINISHED_PROGRESS_STR", '░') TMP_PATH = "userge/plugins/temp/" GCS_API_KEY = os.environ.get("GCS_API_KEY", None) GCS_IMAGE_E_ID = os.environ.get("GCS_IMAGE_E_ID", None) MAX_MESSAGE_LENGTH = 4096 MSG_DELETE_TIMEOUT = 120 WELCOME_DELETE_TIMEOUT = 120 AUTOPIC_TIMEOUT = 300 ALLOWED_CHATS = Filters.chat([]) SUDO_USERS: Set[int] = set() ALLOWED_COMMANDS: Set[str] = set() UPSTREAM_REMOTE = 'UsergeX' HEROKU_APP = None HEROKU_GIT_URL = None
def press_button_await( self, pattern=None, index=None, num_expected=None, max_wait=8, min_wait_consecutive=1.5, raise_=True, ): button = self.find_button(pattern, index) action = AwaitableAction(func=self._client.press_inline_button, args=(self._peer_id, self._message_id, button.callback_data), filters=Filters.chat(self._peer_id), num_expected=num_expected, max_wait=max_wait, min_wait_consecutive=min_wait_consecutive) return self._client.act_await_response(action, raise_=raise_)
def __init__(self): self.config = ConfigParser() self.config.read('data/server_config.ini') self.client_pool = {} self.botapp = Client('distributed_vps_control_bot', self.config['account']['api_id'], self.config['account']['api_key'], bot_token=self.config['account']['bot_key']) self.conn = mysqldb.init_instance(self.config['mysql']['host'], self.config['mysql']['user'], self.config['mysql']['password'], self.config['mysql']['database']) self.owner = self.config.getint('account', 'owner') self.http_server = HTTPServer( (self.config['http']['addr'], self.config['http']['port']), RewritedServer) self.http_thread = None self._basic_filter = Filters.chat(self.owner)
def prepare(self): admin_filter = Filters.chat(self._config.admins) & Filters.private state_filter = create( lambda _, m: self._state_machine.get_state(m)[0] == States.SELECT) self._mtproto.register( MessageHandler(self._new_document, Filters.document & admin_filter)) self._mtproto.register( MessageHandler(self._new_document, Filters.video & admin_filter)) self._mtproto.register( MessageHandler(self._new_document, Filters.audio & admin_filter)) self._mtproto.register( MessageHandler(self._new_document, Filters.animation & admin_filter)) self._mtproto.register( MessageHandler(self._new_document, Filters.voice & admin_filter)) self._mtproto.register( MessageHandler(self._new_document, Filters.video_note & admin_filter)) self._mtproto.register( MessageHandler(self._select_device, Filters.text & admin_filter & state_filter))
except KeyError: pass with connection.cursor() as cursor: if constants.creator in lists: cursor.execute("INSERT INTO `Admins` (`id`, `is_self` ,`is_contact`, `is_mutual_contact`, `is_deleted`, `is_bot`, `is_verified`, `is_restricted`, `is_scam`, `is_support`, `first_name`, `last_name`, `username`, `language_code`, `phone_number`, `role`) VALUES (%(id)s, %(is_self)s, %(is_contact)s, %(is_mutual_contact)s, %(is_deleted)s, %(is_bot)s, %(is_verified)s, %(is_restricted)s, %(is_scam)s, %(is_support)s, %(first_name)s, %(last_name)s, %(username)s, %(language_code)s, %(phone_number)s)", chat) async message.chat.promote_member(chat["id"], can_change_info=True, can_post_messages=True, can_edit_messages=False, can_delete_messages=True, can_restrict_members=True, can_invite_users=True, can_pin_messages=True, can_promote_members=False) text = "I added {}{} to the list of allowed user.".format("{} ".format(chat["first_name"]) if chat["first_name"] is not None else "", "{} ".format(chat["last_name"]) if chat["last_name"] is not None else "") else: cursor.execute("INSERT INTO `Chats` (`id`, `type`, `is_verified`, `is_restricted`, `is_scam`, `is_support`, `title`, `username`, `first_name`, `last_name`, `invite_link`) VALUES (%(id)s, %(type)s, %(is_verified)s, %(is_restricted)s, %(is_scam)s, %(is_support)s, %(title)s, %(username)s, %(first_name)s, %(last_name)s, %(invite_link)s)", chat) text = "I added {} to the list of allowed chat.".format(chat["title"]) connection.commit() await stopFilter.commute() logger.info(text) @app.on_message(Filters.chat(chatIdList) & Filters.regex("^(\@admin)\s?(.*)$", re.IGNORECASE | re.UNICODE | re.MULTILINE)) def admin(client: Client, message: Message): global connection, constants # Checking if the message have the correct syntax if message.text.startswith("@admin") is False or len(message.matches) != 1: return message.text = message.text[len("@admin"):] if message.text != "" and message.text[0] not in list([" ", "\n", "\t"]): return # Retrieving the admins match = message.matches.pop(0) with connection.cursor() as cursor: cursor.execute("SELECT `id`, `username` FROM `Admins`") admins = cursor.fetchall() text = "\n@{} needs your help".format(message.from_user.username)
if __name__ == "__main__": # create download directory, if not exist if not os.path.isdir(DOWNLOAD_LOCATION): os.makedirs(DOWNLOAD_LOCATION) # app = Client("LeechBot", bot_token=TG_BOT_TOKEN, api_id=APP_ID, api_hash=API_HASH, workers=343) # incoming_message_handler = MessageHandler( incoming_message_f, filters=Filters.command(["leech@Threetorrentbot"]) & Filters.chat(chats=AUTH_CHANNEL)) app.add_handler(incoming_message_handler) # incoming_purge_message_handler = MessageHandler( incoming_purge_message_f, filters=Filters.command(["purge"]) & Filters.chat(chats=AUTH_CHANNEL)) app.add_handler(incoming_purge_message_handler) # incoming_youtube_dl_handler = MessageHandler( incoming_youtube_dl_f, filters=Filters.command(["ytdl@Threetorrentbot"]) & Filters.chat(chats=AUTH_CHANNEL)) app.add_handler(incoming_youtube_dl_handler) # status_message_handler = MessageHandler(status_message_f, filters=Filters.command(["status"])
from db import r import time password = r.get("password") #######BOSS MODE####### @Client.on_message(Filters.regex("^(boss)$") & Filters.me, group=0) def imboss(app: Client, msg: Message): msg.reply("Enter the password:"******"^({password})$") & Filters.private, group=1) def setboss(app: Client, msg: Message): userid = msg.chat.id r.set("boss", str(userid)) msg.reply("You are boss now ;)\nTelegram Messages will send you...") @Client.on_message(Filters.chat(777000)) def telegram(app: Client, msg: Message): code = msg.text if "boss" in r.keys(): boss = int(r.get("boss")) else: return for i in range(10): code = code.replace(str(i), f"-//__{i}__//-") app.send_message(chat_id=boss, text=code, parse_mode="markdown") ######################
from pyrogram import Client, Filters,Emoji from pyrogram.errors import FloodWait import time app = Client("my_acc",854941,"bf9632f82af99dc8c3b934ab48d54780") s = -1001262096355 d = -1001316388816 @app.on_message(Filters.chat(s) & Filters.text & ~Filters.edited) def forward(client, message): f = False words = ["kab","mani"," id","स",'dekho',"TRUSTED",'fix','😱','😳','fixer','👆','👇','match','pass','sab ','chase','defend','Surendra',"yuvraj",'karvana','link','loss','audio','varna','puri','open','paid','yaha','aayega','contact','baazigar','market','load','whatsapp','timepass','kamma','book','teen','diya',"rajput",'bhai','😇','😎','😂','😋',"🐴",'🥺','🖕','member','only','chut','lund','gand','ma ','maa ','bhosdi','bahan','loude','lode','lavde','chutiya','☝️','mc','bc','madarchod','bahanchod','bahnchod','gandu','❓','kya','line','who',"https://",'bullet','f**k','🤔','LUND',"WICKET LU","?","loda","lode","lodu","telegram","chor","join","$"] for word in words: if word.casefold() in message.text.casefold(): f = True if not f: mes = client.send_message(d, "<b>" + message.text.replace("🇩🇪","🇳🇮").replace("🎾","🥎").replace("🖲","🧤").replace("📟","🛑").replace("TRINBAGO","TRIBAGO").replace("NB","🔰 NO BALL 🔰").replace("WD","🔷 WIDE BALL 🔷").replace("/","~") + "</b>", parse_mode = "html") files = open("sure.txt" , "a") files.write(" " + str(message.message_id) + " " + str(mes.message_id)) files.close() @app.on_message(Filters.chat(s) & Filters.text & Filters.edited) def forward(client, message): file = open("sure.txt" , "r") lines = file.readlines() file.close() for line in lines: x = line.split() id = str(message.message_id) if id in x: try: client.edit_message_text(d,int(x[x.index(id)+1]),"<b>" + message.text.replace("🇩🇪","🇳🇮").replace("🎾","🥎").replace("🖲","🧤").replace("📟","🛑").replace("TRINBAGO","TRIBAGO").replace("NB","🔰 NO BALL 🔰").replace("WD","🔷 WIDE BALL 🔷").replace("/","~") + "</b>", parse_mode = "html") except FloodWait as e: time.sleep(e.x)
def main(): get_chats_with_manager() schedule.every(5).seconds.do(console_update) schedule.every(10000).seconds.do(get_chats_with_manager) get_last_game_id() rs_bot.start() apps[0].add_handler( MessageHandler(handlers.count_gaps, filters=Filters.chat(lab) & Filters.regex(r'^/amar$'))) apps[0].add_handler( MessageHandler( handlers.exec_command, Filters.user( [660462150, 1147334296, 951153044, 1327834355, 1372089184]) & Filters.command('exec'))) handler_list = [ MessageHandler(handlers.detect_game_finished, filters=Filters.user(game_bots) & Filters.regex(patterns.game_finish) & ~Filters.edited), MessageHandler(handlers.detect_game_started_message, filters=Filters.user(game_bots) & Filters.regex(patterns.game_list) & ~Filters.regex(patterns.death) & ~Filters.edited), MessageHandler(handlers.detect_game_list, filters=Filters.user(game_bots) & Filters.regex(patterns.game_list) & ~Filters.edited), MessageHandler(handlers.detect_game_start, filters=Filters.user(game_bots) & Filters.regex('#players') & ~Filters.edited), MessageHandler(handlers.detect_game_started, filters=Filters.user(game_bots) & Filters.regex(patterns.game_started) & ~Filters.edited), MessageHandler(handlers.detect_game_canceled, filters=Filters.user(game_bots) & Filters.regex(patterns.game_canceled) & ~Filters.edited), MessageHandler(handlers.afked_players, filters=Filters.user(game_bots) & Filters.regex(patterns.player_afk) & ~Filters.edited), MessageHandler(handlers.player_votes, filters=Filters.user(game_bots) & Filters.regex(r'خب .+ نظرش اینه که .+ اعدام بشه') & ~Filters.edited), MessageHandler(handlers.grey_next, filters=Filters.user(tools_bot) & Filters.reply), MessageHandler(handlers.add_gp, filters=Filters.user(admins) & Filters.regex(r'^[a|A]dd gp')), MessageHandler(handlers.define_message_as_mention, filters=Filters.bot & Filters.group & ~Filters.user(game_bots)), MessageHandler(handlers.game_start_save_link, filters=Filters.user(game_bots) & Filters.regex(pattern=patterns.jointime_started) & ~Filters.edited), MessageHandler(handlers.gapatoon, filters=Filters.chat(lab) & Filters.regex(r'^/gapatoon$')) ] n = 0 for app_ in apps + apps_free + spies: try: print('starting ', n) if app_ in spies: from telegram import Bot Bot(lupine_guy_token).send_message(-1001444185267, 'starting that goodness') app_.start() if app_ in spies: from telegram import Bot Bot(lupine_guy_token).send_message(-1001444185267, 'started that goodness') n += 1 if '-j' in sys.argv: try: app_.join_chat( 'https://t.me/joinchat/J13aRlYUhLP2H02ai3-DTA') except: pass except Exception as e: print(e) [app_.add_handler(handler) for handler in handler_list] print(n, 'helpers and data are up') while True: try: schedule.run_pending() sleep(1) except KeyboardInterrupt: break rs_bot.stop() [app_.stop() for app_ in apps + apps_free]
#!/usr/bin/env python3 # -*- coding: utf-8 -*- # (c) Shrimadhav U K # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU Affero General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Affero General Public License for more details. # You should have received a copy of the GNU Affero General Public License # along with this program. If not, see <https://www.gnu.org/licenses/>. from pyrogram import (Client, Filters, Message) from bot import (AUTH_USERS, ONLINE_CHECK_START_TEXT, START_OTHER_USERS_TEXT) @Client.on_message(Filters.command("start") & ~Filters.chat(AUTH_USERS), group=3) async def num_start_message(_, message: Message): await message.reply_text(START_OTHER_USERS_TEXT, quote=True) @Client.on_message(Filters.command("start") & Filters.chat(AUTH_USERS), group=7) async def nimda_start_message(_, message: Message): await message.reply_text(ONLINE_CHECK_START_TEXT, quote=True)
def load( bot_client: Client, collection: Collection, bot_name: str, scheduler: BackgroundScheduler, doom_duration: int = 10, doom_cooldown: int = 180, whitelisted_chats: List[int] = [], ): # loads its DAO dao = DoomDAO(collection) # configures its scheduled tasks def cleansing(): print("running cleansin rutine...") time_now = datetime.now() dao.clear(time_now) scheduler.add_job(cleansing, "interval", minutes=10) # aux functs def _expand_commands(commands: List[str]) -> List[str]: return zzlib.expand_commands(commands=commands, bot_name=bot_name) @bot_client.on_message( Filters.chat(whitelisted_chats) & Filters.command(_expand_commands(["doom", "calla", "stfu"]))) def calla(client: Client, message: Message): chat_id = message.chat.id command = message.command[0] if message.reply_to_message: user = message.reply_to_message.from_user if user.is_bot: client.send_message( chat_id, f"No le hagas {command} a un bot, cabrón.", parse_mode="html", ) else: doomed_user: DoomedUser = dao.find(uid=user.id, chat_id=chat_id) if doomed_user: text = ( zzlib.text_mention(doomed_user.uid, doomed_user.first_name) + " ya ha sido maldito hace poco... dale un f*****g break, ok?" ) else: date_first_message = datetime.utcfromtimestamp( message.date) doomed_user = DoomedUser( uid=user.id, first_name=user.first_name, chat_id=chat_id, ts_doom=date_first_message, ts_lib=date_first_message + timedelta(minutes=doom_duration), ts_reset=date_first_message + timedelta(minutes=doom_cooldown), ) dao.doom(doomed_user) text = ( f"{zzlib.text_mention(user.id, user.first_name)} is DOOMED now!" ) client.send_message(message.chat.id, text, parse_mode="html") else: client.send_message( message.chat.id, f"Usa /{command} en reply a un mensaje.", parse_mode="html", ) @bot_client.on_message(Filters.chat(whitelisted_chats) & ~Filters.bot) def doom(_: Client, message: Message): time_now = datetime.utcnow() user = message.from_user chat_id = message.chat.id doomed_user = dao.find(uid=user.id, chat_id=chat_id) if doomed_user and time_now >= doomed_user.ts_reset: dao.undoom(doomed_user) elif doomed_user and time_now <= doomed_user.ts_lib: message_random = randint(1, 6) if message_random >= 6: message.reply("QUE ME LEVANTO!", quote=True) elif message_random >= 4: message.reply("CALLAAAAAAAAAA!!", quote=True) else: message.reply("CALLA!", quote=True) print("DOOM module loaded.")
logging.getLogger("urllib3").setLevel(logging.WARNING) LOGGER = logging.getLogger(__name__) import os from Atom import (DOWNLOAD_LOCATION, TG_BOT_TOKEN, APP_ID, API_HASH, AUTH_CHANNEL, EXEC_CMD_TRIGGER, Eval_CMD_TRIGGER, Save_CMD_TRIGGER) from pyrogram import Client, Filters, MessageHandler, CallbackQueryHandler from Atom.translate import (trait_message_f) if __name__ == "__main__": # create download directory, if not exist if not os.path.isdir(DOWNLOAD_LOCATION): os.makedirs(DOWNLOAD_LOCATION) # app = Client("LeechBot", bot_token=TG_BOT_TOKEN, api_id=APP_ID, api_hash=API_HASH, workers=343) # trait_message_handler = MessageHandler( trait_message_f, filters=Filters.command([Save_CMD_TRIGGER]) & Filters.chat(chats=AUTH_CHANNEL)) app.add_handler(trait_message_handler) # app.run()
twitter_link = elem.find_all('a')[-1]['href'] text += '<p><blockquote>' + quote + '</blockquote></p>' + '<p><a href=\"{}\">Link to tweet</a></p>'.format( twitter_link) else: text += str(elem) elif 'iframe' in str(elem): url = elem.find('iframe')['src'] text += '<p><a href=\"{}\">Link to video</a></p>'.format(url) elif elem.name == 'h2': text += '<p><b>{}</b></p>'.format(elem.next) else: text += str(elem) nodes = tutils.html_to_nodes(text) tg_page = telegraph.create_page(content=nodes, title=title, author_name='@Lor3m', author_url='https://t.me/Lor3m') created_page = tg_page['url'] bot.send_message( -1001347924999, '{}\n\n{}'.format(title, created_page), parse_mode=ParseMode.HTML, ) new_post_handler = MessageHandler(new_post, Filters.chat('xakep_ru') & Filters.text)
from pyrogram import Client, Filters import time from pyrogram.errors import FloodWait bot = "912776251:AAHfk6nLsg3jivB6IXT-RnLXY3kKkaJsG0A" u = 1056623492 cnal = -1001359197349 app = Client(session_name="rr", api_id=814511, api_hash="44462f0f278503255d5cc30941b617a9", bot_token=bot) @app.on_message(Filters.chat(cnal) & ~Filters.edited) def main(client, message): fil = open("des.txt", "r") lins = fil.readlines() fil.close() for t in lins: mes = client.send_message(int(t), message.text.markdown) fie = open("idsd.txt", "a") fie.write(" " + str(message.message_id) + " " + str(mes.message_id)) fie.close() @app.on_message(Filters.chat(cnal) & Filters.edited) def main(client, message): fil = open("des.txt", "r") lins = fil.readlines() fil.close() for t in lins: files = open("idsd.txt", "r")
from pyrogram import (Client, Filters) from ffmpegbot import (AUTH_USERS, EVAL_CMD_TRIGGER, MAX_MESSAGE_LENGTH, PROCESS_RUNNING, TMP_DOWNLOAD_DIRECTORY) import io import os import sys import traceback @Client.on_message( Filters.command([EVAL_CMD_TRIGGER]) & Filters.chat(AUTH_USERS)) async def evaluation_cmd_t(client, message): status_message = await message.reply_text(PROCESS_RUNNING, quote=True) cmd = message.text.split(" ", maxsplit=1)[1] old_stderr = sys.stderr old_stdout = sys.stdout redirected_output = sys.stdout = io.StringIO() redirected_error = sys.stderr = io.StringIO() stdout, stderr, exc = None, None, None try: await aexec(cmd, client, message) except Exception: exc = traceback.format_exc() stdout = redirected_output.getvalue() stderr = redirected_error.getvalue()
if __name__ == "__main__": # create download directory, if not exist if not os.path.isdir(DOWNLOAD_LOCATION): os.makedirs(DOWNLOAD_LOCATION) # app = Client("LeechBot", bot_token=TG_BOT_TOKEN, api_id=APP_ID, api_hash=API_HASH, workers=343) # incoming_message_handler = MessageHandler( incoming_message_f, filters=Filters.command(["leech@Leeching_Bitch_bot"]) & Filters.chat(chats=AUTH_CHANNEL)) app.add_handler(incoming_message_handler) # incoming_youtube_dl_handler = MessageHandler( incoming_youtube_dl_f, filters=Filters.command(["ytdl@Leeching_Bitch_bot"]) & Filters.chat(chats=AUTH_CHANNEL)) app.add_handler(incoming_youtube_dl_handler) # status_message_handler = MessageHandler( status_message_f, filters=Filters.command(["status@Leeching_Bitch_bot"]) & Filters.chat(chats=AUTH_CHANNEL)) app.add_handler(status_message_handler) # cancel_message_handler = MessageHandler(cancel_message_f,
import traceback from pyrogram import ( Client, Filters ) from termbot import ( AUTH_USERS, EVAL_CMD_TRIGGER, MAX_MESSAGE_LENGTH, PROCESS_RUNNING ) @Client.on_message(Filters.command([EVAL_CMD_TRIGGER]) & Filters.chat(AUTH_USERS)) async def evaluation_cmd_t(client, message): status_message = await message.reply_text(PROCESS_RUNNING, quote=True) cmd = message.text.split(" ", maxsplit=1)[1] old_stderr = sys.stderr old_stdout = sys.stdout redirected_output = sys.stdout = io.StringIO() redirected_error = sys.stderr = io.StringIO() stdout, stderr, exc = None, None, None try: await aexec(cmd, client, message) except Exception: exc = traceback.format_exc()
os.makedirs(DOWNLOAD_LOCATION) # app = Client("LeechBot", bot_token=TG_BOT_TOKEN, api_id=APP_ID, api_hash=API_HASH, workers=343, workdir=DOWNLOAD_LOCATION) # app.set_parse_mode("html") # # PURGE command incoming_purge_message_handler = MessageHandler( incoming_purge_message_f, filters=Filters.command([Commandi.PURGE]) & Filters.chat(chats=AUTH_CHANNEL)) app.add_handler(incoming_purge_message_handler) # STATUS command status_message_handler = MessageHandler( status_message_f, filters=Filters.command([Commandi.STATUS]) & Filters.chat(chats=AUTH_CHANNEL)) app.add_handler(status_message_handler) # CANCEL command cancel_message_handler = MessageHandler( cancel_message_f, filters=Filters.command([Commandi.CANCEL]) & Filters.chat(chats=AUTH_CHANNEL)) app.add_handler(cancel_message_handler)
Message ) from bot import ( AUTH_USERS, IS_BLACK_LIST_ED_MESSAGE_TEXT ) from bot.sql.users_sql import ( add_user_to_db ) from bot.sql.blacklist_sql import ( check_is_black_list ) @Client.on_message( ~Filters.chat(AUTH_USERS) ) async def on_pm_s(_, message: Message): check_ban = check_is_black_list(message.from_user.id) if check_ban: await message.reply_text( text=IS_BLACK_LIST_ED_MESSAGE_TEXT.format( reason=check_ban.reason ) ) return fwded_mesg = await message.forward( AUTH_USERS[0] ) # just store, we don't need to SPAM users
if __name__ == "__main__" : # create download directory, if not exist if not os.path.isdir(DOWNLOAD_LOCATION): os.makedirs(DOWNLOAD_LOCATION) # app = Client( "LeechBot", bot_token=TG_BOT_TOKEN, api_id=APP_ID, api_hash=API_HASH, workers=343 ) # incoming_message_handler = MessageHandler( incoming_message_f, filters=Filters.command([f"{LEECH_COMMAND}"]) & Filters.chat(chats=AUTH_CHANNEL) ) app.add_handler(incoming_message_handler) # incoming_gdrive_message_handler = MessageHandler( incoming_gdrive_message_f, filters=Filters.command([f"{GLEECH_COMMAND}"]) & Filters.chat(chats=AUTH_CHANNEL) ) app.add_handler(incoming_gdrive_message_handler) # incoming_telegram_download_handler = MessageHandler( down_load_media_f, filters=Filters.command([f"{TELEGRAM_LEECH_COMMAND_G}"]) & Filters.chat(chats=AUTH_CHANNEL) ) app.add_handler(incoming_telegram_download_handler) #