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)
#
