def init(client: '_client.Userge') -> None:
""" initialize the conversation method """
async def _on_conversation(_, msg: RawMessage) -> None:
data = _CONV_DICT[msg.chat.id]
if isinstance(data, asyncio.Queue):
data.put_nowait(msg)
elif msg.from_user and msg.from_user.id == data[0]:
data[1].put_nowait(msg)
msg.continue_propagation()
client.add_handler(
MessageHandler(
_on_conversation,
filters.create(
lambda _, __, query: _CONV_DICT and query.chat and query.
chat.id in _CONV_DICT, 0)))
def __init__(self, command: str, source: str, result_str: str):
self.command = command
self.source = source.rstrip('/')
self.RESULT_STR = result_str
app.add_handler(
MessageHandler(
self.find,
filters.command([command, f'{self.command}@{bot.username}'])))
app.add_handler(
CallbackQueryHandler(self.previous,
filters.regex(f"{self.command}_previous")))
app.add_handler(
CallbackQueryHandler(self.delete,
filters.regex(f"{self.command}_delete")))
app.add_handler(
CallbackQueryHandler(self.next,
filters.regex(f"{self.command}_next")))
def init_message_handler(self) -> None:
if self._listen_to_group[0] == 0:
raise ValueError('listen_to_group value must be set')
self.client_group[0].add_handler(
MessageHandler(
self.handle_set_target,
filters.chat(self.owner) & filters.command('target')))
self.client_group[0].add_handler(
MessageHandler(
self.handle_resend_command,
filters.user(self.owner) & filters.chat(self._listen_to_group)
& filters.command('resend')))
self.client_group[0].add_handler(
MessageHandler(self.handle_toggle_debug_command,
filters.chat(self.owner)
& filters.command('debug')))
self.client_group[0].add_handler(
MessageHandler(
self.handle_normal_resident,
filters.chat(self._listen_to_group)
& filters.user(self.WEREWOLF_BOT_ID) & filters.text))
self.client_group[0].add_handler(
MessageHandler(
self.handle_join_game,
filters.chat(self._listen_to_group)
& filters.user(self.WEREWOLF_BOT_ID)))
self.client_group[0].add_handler(
MessageHandler(
self.handle_close_auto_join,
filters.chat(self._listen_to_group) & filters.command('off')))
self.client_group[0].add_handler(
MessageHandler(
self.handle_set_num_worker,
filters.chat(self._listen_to_group) & filters.command('setw')))
for x in self.client_group:
x.add_handler(
MessageHandler(
self.handle_werewolf_game,
filters.chat(self.WEREWOLF_BOT_ID) & filters.incoming))
logger.debug('Current workers: %d', len(self.client_group))
async def start(self: "Bot") -> None:
self.log.info("Starting")
await self.init_client()
# Load modules
self.load_all_modules()
await self.dispatch_event("load")
self.loaded = True
# iter first because can't use *.keys()
commands = []
for cmd in self.commands.keys():
commands.append(cmd)
self.client.add_handler(
MessageHandler(self.on_command,
filters=(pyrogram.filters.command(
commands, prefixes=".", case_sensitive=True)
& pyrogram.filters.me
& pyrogram.filters.outgoing)), 0)
async with silent():
await self.client.start()
user = await self.client.get_me()
if not isinstance(user, pyrogram.types.User):
raise TypeError("Missing full self user information")
self.user = user
self.uid = user.id
await self.dispatch_event("start")
self.log.info("Bot is ready")
await self.dispatch_event("aria", await aria.initialize(self.http))
self.aria = aria2p.API(
aria2p.Client(host="http://localhost", port=6800, secret=""))
await self.dispatch_event("started")
async def get_name(client, message):
"""
Отримання імені
Відсутнє обмеження на знаки/цифри і т.д., щоб обмежити це -
при додаванні хендлера get_name можна додати filters.regex("^[a-zA-Z]+$")
"""
# Збережемо вибір статі в історію активності
append_history(message.from_user.id, "Get name")
# Name: 2-20 chars
if 2 <= len(message.text) <= 20:
await message.reply_text(f'Окей, {message.text}.')
# Зберігаємо попереднє значення імені користувача
previous_name = active_users[message.from_user.id]["name"]
# Записуємо ім'я в словник під ключем телеграм айді користувача
active_users[message.from_user.id]["name"] = message.text
# Видаляємо попередній handler на отримання імені
delete_handlers(message.from_user.id)
# Якщо під ключем age вже було значення, це значить handler був доданий у change_age()
if previous_name:
# Зберігаємо інформацію про користувача
await save_information(message)
else:
await message.reply_text("Введіть Ваш вік")
# Створюємо новий handler на отримання віку
active_users[message.from_user.id]["handler"].append(
app.add_handler(
MessageHandler(get_age,
filters.regex("^[0-9]+$") & filters.user(message.from_user.id) & filters.private))
)
else:
await message.reply_text("Ім'я повинно містити 2-20 літер")
def run(self) -> None:
logger.info(mp.current_process().name)
logger.info(threading.current_thread())
client = get_client(self.client_name, False)
client.start()
self.client = client
me = client.get_me()
logger.info(me)
client.add_handler(DisconnectHandler(self.on_disconnect))
client.add_handler(MessageHandler(self.on_message))
client.add_handler(RawUpdateHandler(self.on_raw_update))
worker = ClientWorkerThread(
client=client,
index=0,
db=self.db,
task_queues=self.task_queues,
)
worker.start()
idle()
client.stop()
def init_message_handler(self) -> None:
self.app.add_handler(
MessageHandler(self.handle_auth,
filters.command('auth') & filters.private))
self.app.add_handler(
MessageHandler(self.pre_check, filters.text & filters.private))
self.app.add_handler(
MessageHandler(self.handle_passcode,
filters.text & filters.private))
self.app.add_handler(CallbackQueryHandler(self.handle_callback_query))
self.app.add_handler(
MessageHandler(self.pre_check_owner,
filters.text & filters.private))
self.app.add_handler(
MessageHandler(self.query_history,
filters.command('h') & filters.private))
self.app.add_handler(
MessageHandler(self.delete_user_manual,
filters.command('del') & filters.private))
def prepare(self):
admin_filter = filters.chat(self._config.admins) & filters.private
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))
state_filter = create(lambda _, __, m: self._state_machine.get_state(m)
[0] == States.SELECT)
self._mtproto.register(
MessageHandler(self._select_device,
filters.text & admin_filter & state_filter))
from pyrogram import filters
from pyrogram.handlers import MessageHandler
from pyrogram.types import InlineKeyboardMarkup, InlineKeyboardButton
from config import BANNED
from strings import get_string as _
async def start(client, message):
await message.reply_text(_("start_1", True),
reply_markup=InlineKeyboardMarkup([[
InlineKeyboardButton(
_("start_2"),
switch_inline_query_current_chat="")
]]))
__handlers__ = [[
MessageHandler(start,
filters.command("start", "/")
& filters.private
& ~BANNED)
]]
__help__ = {"start": [_("help_start"), False]}
if __name__ == "__main__":
# create download directory, if not exist
if not os.path.isdir(DOWNLOAD_LOCATION):
os.makedirs(DOWNLOAD_LOCATION)
#
app = Client(SESSION_NAME,
bot_token=TG_BOT_TOKEN,
api_id=APP_ID,
api_hash=API_HASH,
workers=2)
#
app.set_parse_mode("html")
#
# STATUS ADMIN Command
incoming_status_command = MessageHandler(
sts, filters=filters.command(["status"]) & filters.user(AUTH_USERS))
app.add_handler(incoming_status_command)
# BAN Admin Command
incoming_ban_command = MessageHandler(ban,
filters=filters.command(["ban_user"])
& filters.user(AUTH_USERS))
app.add_handler(incoming_ban_command)
# UNBAN Admin Command
incoming_unban_command = MessageHandler(
unban,
filters=filters.command(["unban_user"]) & filters.user(AUTH_USERS))
app.add_handler(incoming_unban_command)
# BANNED_USERS Admin Command
def init_handle(self) -> None:
self.app.add_handler(
MessageHandler(self.get_msg_from_owner_group,
filters.chat(self.owner_group_id) & filters.reply))
self.app.add_handler(
MessageHandler(
self.get_command_from_target,
filters.chat(self.configure.predefined_group_list)
& filters.text & filters.reply))
self.app.add_handler(
MessageHandler(
self.pre_check, filters.media & ~filters.private
& ~filters.sticker & ~filters.voice & ~filters.web_page))
self.app.add_handler(
MessageHandler(
self.handle_photo, filters.photo & ~filters.private
& ~filters.chat([self.configure.photo, self.configure.lowq])))
self.app.add_handler(
MessageHandler(
self.handle_video, filters.video & ~filters.private
& ~filters.chat(self.configure.video)))
self.app.add_handler(
MessageHandler(
self.handle_gif, filters.animation & ~filters.private
& ~filters.chat(self.configure.gif)))
self.app.add_handler(
MessageHandler(
self.handle_document, filters.document & ~filters.private
& ~filters.chat(self.configure.doc)))
self.app.add_handler(
MessageHandler(
self.handle_other, filters.media & ~filters.private
& ~filters.sticker & ~filters.voice & ~filters.web_page))
self.app.add_handler(MessageHandler(self.pre_private, filters.private))
self.app.add_handler(
MessageHandler(self.handle_add_bypass,
filters.command('e') & filters.private))
self.app.add_handler(
MessageHandler(self.process_query,
filters.command('q') & filters.private))
self.app.add_handler(
MessageHandler(self.handle_add_black_list,
filters.command('b') & filters.private))
self.app.add_handler(
MessageHandler(self.process_show_detail,
filters.command('s') & filters.private))
self.app.add_handler(
MessageHandler(
self.set_forward_target_reply,
filters.command('f') & filters.reply & filters.private))
self.app.add_handler(
MessageHandler(self.set_forward_target,
filters.command('f') & filters.private))
self.app.add_handler(
MessageHandler(self.add_user,
filters.command('a') & filters.private))
self.app.add_handler(
MessageHandler(self.change_code,
filters.command('pw') & filters.private))
self.app.add_handler(
MessageHandler(self.undo_blacklist_operation,
filters.command('undo') & filters.private))
self.app.add_handler(
MessageHandler(self.switch_detail2,
filters.command('sd2') & filters.private))
self.app.add_handler(
MessageHandler(self.switch_detail,
filters.command('sd') & filters.private))
self.app.add_handler(
MessageHandler(self.show_help_message,
filters.command('help') & filters.private))
self.app.add_handler(
MessageHandler(self.process_private, filters.private))
def decorator(func):
async def wrapper(client, message):
chat_type = message.chat.type
if only_if_admin and not await is_admin_or_owner(
message, (client.me).id):
await edit_or_reply(
message,
"`This Command Only Works, If You Are Admin Of The Chat!`")
return
if group_only and chat_type != "supergroup":
await edit_or_reply(message, "`Are you sure this is a group?`")
return
if chnnl_only and chat_type != "channel":
await edit_or_reply(message,
"This Command Only Works In Channel!")
return
if pm_only and chat_type != "private":
await edit_or_reply(message, "`This Cmd Only Works On PM!`")
return
if ignore_errors:
await func(client, message)
else:
try:
await func(client, message)
except StopPropagation:
raise StopPropagation
except KeyboardInterrupt:
pass
except MessageNotModified:
pass
except MessageIdInvalid:
logging.warning(
"Please Don't Delete Commands While it's Processing..")
except UserNotParticipant:
pass
except ContinuePropagation:
raise ContinuePropagation
except BaseException as e:
logging.error(
f"Exception - {func.__module__} - {func.__name__}")
TZ = pytz.timezone(Config.TZ)
datetime_tz = datetime.now(TZ)
text = "**!ERROR - REPORT!**\n\n"
text += f"\n**Trace Back : ** `{str(format_exc())}`"
text += f"\n**Plugin-Name :** `{func.__module__}`"
text += f"\n**Function Name :** `{func.__name__}` \n"
text += datetime_tz.strftime(
"**Date :** `%Y-%m-%d` \n**Time :** `%H:%M:%S`")
text += "\n\n__You can Forward This to @WhiteDevil_Support, If You Think This is Serious A Error!__"
try:
await client.send_message(Config.LOG_GRP, text)
except BaseException:
logging.error(text)
message.continue_propagation()
Friday.add_handler(MessageHandler(wrapper, filters=filterm), group)
if Friday2:
Friday2.add_handler(MessageHandler(wrapper, filters=filterm),
group)
if Friday3:
Friday3.add_handler(MessageHandler(wrapper, filters=filterm),
group)
if Friday4:
Friday4.add_handler(MessageHandler(wrapper, filters=filterm),
group)
return wrapper
from pyrogram import filters
from pyrogram.handlers import MessageHandler
import player
from helpers import State
from config import SUDO_FILTER
from strings import get_string as _
def skip(client, message):
if player.STATE in (State.Playing, State.Streaming, State.Paused):
player.STATE = State.Skipped
player.abort()
message.reply_text(_("skip_1"))
else:
message.reply_text(_("skip_2"))
__handlers__ = [[
MessageHandler(skip,
filters.command("skip", "/")
& SUDO_FILTER)
]]
__help__ = {"skip": [_("help_skip"), True]}
download(
(m.edit, (_("downloading"), )),
(m.edit, (_("downloaded_scheduled").format(player.q.qsize() + 1), )), [
player.play,
[
None, (message.reply_text, (_("playing"), )),
(message.reply_text, (_("finished_playing"), )), None, None,
message.from_user.id, message.from_user.first_name,
[
client.send_message,
[
LOG_GROUP,
_("group_log").format(
"<a href=\"{}\">{}</a>",
"<a href=\"tg://user?id={}\">{}</a>", "{}")
]
] if LOG_GROUP else None, None,
(message.reply_text, (_("on_skip"), ))
]
], (m.edit, (_("not_live"), )), message.text,
(m.edit, (_("err_occ"), )), [m.edit, [
_("dur_limit"),
]])
__handlers__ = [[
MessageHandler(message, filters.text
& filters.private
& ~filters.regex(r"^x .+")), 2
]]
def start_bot():
scheduler = BlockingScheduler()
scheduler = BackgroundScheduler()
scheduler.add_job(new_clock, "interval", seconds=60)
scheduler.add_job(second_clock, "interval", seconds=60)
scheduler.start()
print("开启监控")
sys.stdout.flush()
print("开始bot")
print(Telegram_user_id)
sys.stdout.flush()
aria2.listen_to_notifications(on_download_complete=check_upload, threaded=True)
start_message_handler = MessageHandler(
test,
filters=filters.command("start") & filters.user(int(Telegram_user_id))
filters=filters.command("start") & filters.create(chexk_group)
)
pixivuser_message_handler = MessageHandler(
start_download_pixiv,
filters=filters.command("pixivuser") & filters.user(int(Telegram_user_id))
)
pixivid_message_handler = MessageHandler(
start_download_id,
filters=filters.command("pixivpid") & filters.user(int(Telegram_user_id))
)
magfile_message_handler = MessageHandler(
send_telegram_file,
filters=filters.command("magfile") & filters.user(int(Telegram_user_id))
)
http_download_message_handler = MessageHandler(
start_http_download,
filters=filters.command("mirror") & filters.user(int(Telegram_user_id))
)
magnet_download_message_handler = MessageHandler(
start_download,
filters=filters.command("magnet") & filters.user(int(Telegram_user_id))
)
telegram_file_message_handler = MessageHandler(
get_telegram_file,
filters=filters.command("downtgfile") & filters.user(int(Telegram_user_id))
)
seach_main_file_message_handler = MessageHandler(
seach_main,
filters=filters.command("search") & filters.user(int(Telegram_user_id))
)
start_download_idtg_message_handler = MessageHandler(
start_download_pixivtg,
filters=filters.command("pixivusertg") & filters.user(int(Telegram_user_id))
)
start_http_downloadtg_message_handler = MessageHandler(
start_http_downloadtg,
filters=filters.command("mirrortg") & filters.user(int(Telegram_user_id))
)
start_rclonecopy_message_handler = MessageHandler(
start_rclonecopy,
filters=filters.command("rclonecopy") & filters.user(int(Telegram_user_id))
)
start_rclonelsd_message_handler = MessageHandler(
start_rclonelsd,
filters=filters.command("rclonelsd") & filters.user(int(Telegram_user_id))
)
start_rclone_message_handler = MessageHandler(
start_rclonels,
filters=filters.command("rclone") & filters.user(int(Telegram_user_id))
)
start_rclonecopyurl_message_handler = MessageHandler(
start_rclonecopyurl,
filters=filters.command("rclonecopyurl") & filters.user(int(Telegram_user_id))
)
get_file_id_message_handler = MessageHandler(
get_file_id,
filters=filters.command("getfileid") & filters.user(int(Telegram_user_id))
)
sendfile_by_id_message_handler = MessageHandler(
sendfile_by_id,
filters=filters.command("getfile") & filters.user(int(Telegram_user_id))
)
start_download_pixivphoto_message_handler = MessageHandler(
start_download_pixivphoto,
filters=filters.command("pixivuserphoto") & filters.user(int(Telegram_user_id))
)
start_download_pixivtele_message_handler = MessageHandler(
start_download_pixivtele,
filters=filters.command("pixivusertele") & filters.user(int(Telegram_user_id))
)
start_get_video_info_message_handler = MessageHandler(
start_get_video_info,
filters=filters.command("video") & filters.user(int(Telegram_user_id))
)
start_Resume_handler = CallbackQueryHandler(
callback=start_Resume,
filters=filters.create(lambda _, __, query: "Resume" in query.data )
)
start_pause_handler = CallbackQueryHandler(
callback=start_pause,
filters=filters.create(lambda _, __, query: "Pause" in query.data )
)
start_remove_handler = CallbackQueryHandler(
callback=start_remove,
filters=filters.create(lambda _, __, query: "Remove" in query.data )
)
start_benzi_down_handler = CallbackQueryHandler(
callback=start_benzi_down,
filters=filters.create(lambda _, __, query: "down" in query.data )
)
start_download_video_handler = CallbackQueryHandler(
callback=start_download_video,
filters=filters.create(lambda _, __, query: "video" in query.data )
)
client.add_handler(start_download_video_handler, group=0)
client.add_handler(start_Resume_handler, group=0)
client.add_handler(start_pause_handler, group=0)
client.add_handler(start_remove_handler, group=0)
client.add_handler(start_benzi_down_handler, group=0)
client.add_handler(start_message_handler,group=1)
client.add_handler(pixivuser_message_handler,group=1)
client.add_handler(pixivid_message_handler,group=1)
client.add_handler(magfile_message_handler,group=3)
client.add_handler(http_download_message_handler,group=1)
client.add_handler(magnet_download_message_handler, group=1)
client.add_handler(telegram_file_message_handler, group=1)
client.add_handler(seach_main_file_message_handler, group=1)
client.add_handler(start_download_idtg_message_handler, group=1)
client.add_handler(start_http_downloadtg_message_handler, group=1)
client.add_handler(start_rclonecopy_message_handler , group=1)
client.add_handler(start_rclonelsd_message_handler, group=1)
client.add_handler(start_rclone_message_handler, group=1)
client.add_handler(start_rclonecopyurl_message_handler, group=1)
client.add_handler(get_file_id_message_handler, group=1)
client.add_handler(sendfile_by_id_message_handler, group=1)
client.add_handler(start_download_pixivphoto_message_handler, group=1)
client.add_handler(start_download_pixivtele_message_handler, group=1)
client.add_handler(start_get_video_info_message_handler, group=1)
client.run()
async def clear_downloads(client, message):
player.abort()
try:
for file in os.listdir("downloads"):
try:
os.remove("downloads/" + file)
except:
pass
m = await message.reply_text(_("cleardownloads"))
except:
m = await message.reply_text(_("error"))
if m and message.chat.type != "private":
await sleep(5)
await m.delete()
try:
await message.delete()
except:
pass
__handlers__ = [[
MessageHandler(clear_downloads,
filters.command("cleardownloads", "/")
& SUDO_FILTER)
]]
__help__ = {"cleardownloads": [_("help_cleardownloads"), True]}
print(file)
exit()
elif account == "--add":
num = input("Inserisci il numero della sessione: ")
app = Client(num, api_id=settings.id, api_hash=settings.hash)
app.start()
try:
app.join_chat(settings.chat)
except:
pass
app.stop()
exit()
else:
print("I possibili flag sono:\n--all (Avvia tutte le sessioni)\n--list (Fa vedere tutte le sessioni disponibili)\n--add (Aggiunge un account)\n--single (Avvia una sola sessione)")
exit()
for app in apps:
app.add_handler(MessageHandler(stop, filters.regex("stop") & filters.chat(settings.chatid)))
app.add_handler(MessageHandler(check, filters.regex("check") & filters.chat(settings.chatid)))
app.add_handler(MessageHandler(msgstorm, filters.regex("msgstorm") & filters.chat(settings.chatid)))
app.add_handler(MessageHandler(update, filters.regex("update") & filters.chat(settings.chatid)))
app.add_handler(MessageHandler(join, filters.regex("join") & filters.chat(settings.chatid)))
app.add_handler(MessageHandler(leaveAll, filters.regex("leaveall") & filters.chat(settings.chatid)))
app.add_handler(MessageHandler(aggiungiDB, filters.regex("dbadd") & filters.chat(settings.chatid)))
app.add_handler(MessageHandler(aggiungi, filters.regex("aggiungi") & filters.chat(settings.chatid)))
app.add_handler(MessageHandler(leave, filters.regex("leave") & filters.chat(settings.chatid)))
app.start()
print(str(app.get_me()["phone_number"]) + " avviato")
idle()
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_youtube_dl_handler = MessageHandler(
incoming_youtube_dl_f,
filters=filters.command([f"{YTDL_COMMAND}"]) & filters.chat(chats=AUTH_CHANNEL)
)
app.add_handler(incoming_youtube_dl_handler)
#
incoming_youtube_playlist_dl_handler = MessageHandler(
g_yt_playlist,
filters=filters.command([f"{PYTDL_COMMAND_G}"]) & filters.chat(chats=AUTH_CHANNEL)
)
app.add_handler(incoming_youtube_playlist_dl_handler)
#
#
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_COMMAND,
LEECH_UNZIP_COMMAND,
LEECH_ZIP_COMMAND,
GLEECH_COMMAND,
GLEECH_UNZIP_COMMAND,
GLEECH_ZIP_COMMAND,
]
)
& filters.chat(chats=AUTH_CHANNEL),
)
app.add_handler(incoming_message_handler)
#
incoming_telegram_download_handler = MessageHandler(
down_load_media_f,
filters=filters.command([TELEGRAM_LEECH_COMMAND, TELEGRAM_LEECH_UNZIP_COMMAND])
& filters.chat(chats=AUTH_CHANNEL),
)
app.add_handler(incoming_telegram_download_handler)
#
["pactl", "set-sink-volume", "MySink", volume]).wait()
await message.reply_text(_("volume_2").format(volume))
return
except:
pass
current_volume = "".join(
re.search(r"Volume\:(.+)\n",
subprocess.check_output(
["pactl", "list",
"sinks"]).decode()).group(0).split()).split("/")[1]
if message.from_user.id in SUDO_USERS:
await message.reply_text(
_("volume_1").format(current_volume),
reply_markup=InlineKeyboardMarkup([[
InlineKeyboardButton("➖", callback_data="decrease_volume"),
InlineKeyboardButton("➕", callback_data="increase_volume")
]]),
quote=True)
else:
await message.reply_text(_("volume_1").format(current_volume), )
__handlers__ = [[
MessageHandler(volume,
filters.command("volume", "/")
& ~BANNED)
]]
__help__ = {"volume": [_("help_volume"), False]}
args = message.text.split()
if len(args) == 1:
m = await message.reply_text(_("stream_1"))
elif len(args) != 2:
m = await message.reply_text(_("stream_2"))
else:
player.stream(args[1], [
client.send_message, [LOG_GROUP,
_("group_2").format(args[1])]
] if LOG_GROUP else None)
await message.reply_text(_("stream_4"))
if m and message.chat.type != "private":
await sleep(5)
await m.delete()
try:
await message.delete()
except:
pass
__handlers__ = [[
MessageHandler(stream,
filters.command("stream", "/")
& SUDO_FILTER)
]]
__help__ = {"stream": [_("help_stream"), True]}
# Initialize bot
app = Client(
"Bot",
bot_token=CONFIG.BOT_TOKEN,
api_id=CONFIG.API_ID,
api_hash=CONFIG.API_HASH,
workdir=os_path_join(CONFIG.ROOT, CONFIG.WORKDIR),
plugins=dict(root="bot/handlers")
)
app.set_parse_mode("html")
# register /start handler
app.add_handler(
MessageHandler(
start_message_handler.func,
filters=Filters.command(COMMAND.START)
)
)
if CONFIG.BOT_PASSWORD:
# register /pass handler
app.add_handler(
MessageHandler(
password_handler.func,
filters = Filters.command(COMMAND.PASSWORD)
)
)
# take action on unauthorized chat room
app.add_handler(
MessageHandler(
os.makedirs(DOWNLOAD_LOCATION)
#
sessions = "/app/sessions"
if not os.path.isdir(sessions):
os.makedirs(sessions)
app = Client("SGVideoCompressBot",
bot_token=TG_BOT_TOKEN,
api_id=APP_ID,
api_hash=API_HASH,
workers=2)
#
app.set_parse_mode("html")
#
# START command
incoming_start_message_handler = MessageHandler(
incoming_start_message_f,
filters=filters.command(["start", f"start@{BOT_USERNAME}"]))
app.add_handler(incoming_start_message_handler)
# COMPRESS command
incoming_compress_message_handler = MessageHandler(
incoming_compress_message_f,
filters=filters.command(["compress", f"compress@{BOT_USERNAME}"]))
app.add_handler(incoming_compress_message_handler)
# CANCEL command
incoming_cancel_message_handler = MessageHandler(
incoming_cancel_message_f,
filters=filters.command(["cancel", f"cancel@{BOT_USERNAME}"])
& filters.chat(chats=AUTH_USERS))
app.add_handler(incoming_cancel_message_handler)
async def resume(client, message):
if player.STATE == State.Paused:
player.STATE = State.Playing
player.pause_resume()
m = await message.reply_text(_("resumed"))
else:
m = await message.reply_text(_("cant_resume"))
if m and message.chat.type != "private":
await sleep(5)
await m.delete()
try:
await message.delete()
except:
pass
__handlers__ = [[
MessageHandler(pause,
filters.command("pause", "/")
& SUDO_FILTER)
],
[
MessageHandler(resume, (filters.command("resume", "/")
| filters.command("play", "/"))
& SUDO_FILTER)
]]
def msg_decorator(func):
def wrap(client, message):
if message.empty or not message.from_user:
return
try:
if 'ME' not in TEMP_SETTINGS:
me = app.get_me()
TEMP_SETTINGS['ME'] = me
if me.id in BLACKLIST:
raise RetardsException('RETARDS CANNOT USE THIS BOT')
if message.service and not service:
return
if message.chat.type == 'channel':
return
if not bot and message.chat.type == 'bot':
message.continue_propagation()
if not private and message.chat.type in ['private', 'bot']:
if not disable_notify:
edit(message, f'`{get_translation("groupUsage")}`')
message.continue_propagation()
if not group and 'group' in message.chat.type:
if not disable_notify:
edit(message, f'`{get_translation("privateUsage")}`')
message.continue_propagation()
if admin and not is_admin(message):
if not disable_notify:
edit(message, f'`{get_translation("adminUsage")}`')
message.continue_propagation()
if not compat:
func(client, message)
else:
func(message)
except RetardsException:
try:
system(f'kill -9 {getpid()}')
except BaseException:
pass
except (ContinuePropagation, StopPropagation) as c:
raise c
except Exception as e:
try:
date = strftime("%Y-%m-%d %H:%M:%S", gmtime())
if get_cmd(message) == 'crash':
text = get_translation('logidTest')
else:
if not disable_notify:
edit(message, f'`{get_translation("errorLogSend")}`')
text = get_translation(
'sedenErrorText', ['**', '`', exc_info()[1]]
)
ftext = get_translation(
'sedenErrorText2',
[
date,
message.chat.id,
message.from_user.id if message.from_user else 'Unknown',
BOT_VERSION,
message.text,
format_exc(),
exc_info()[1],
],
)
process = Popen(
['git', 'log', '--pretty=format:"%an: %s"', '-10'],
stdout=PIPE,
stderr=PIPE,
)
out, err = process.communicate()
out = f'{out.decode()}\n{err.decode()}'.strip()
ftext += out
file = open(get_translation('rbgLog'), 'w+')
file.write(ftext)
file.close()
send_log_doc(
get_translation('rbgLog'), caption=text, remove_file=True
)
raise e
except Exception as x:
raise x
filter = None
if pattern:
filter = filters.regex(pattern)
if brain:
filter &= filters.user(BRAIN)
if outgoing and not incoming:
filter &= filters.me
elif incoming and not outgoing:
filter &= filters.incoming & ~filters.bot & ~filters.me
else:
if outgoing and not incoming:
filter = filters.me
elif incoming and not outgoing:
filter = filters.incoming & ~filters.bot & ~filters.me
else:
filter = (filters.me | filters.incoming) & ~filters.bot
if disable_edited:
filter &= ~filters.edited
app.add_handler(MessageHandler(wrap, filter))
m = await message.reply_text(_("n4u"))
if m and message.chat.type != "private":
await sleep(5)
await m.delete()
try:
await message.delete()
except:
pass
__handlers__ = [
[
MessageHandler(
n4u,
(filters.command("pause", "/")
| filters.command("skip", "/")
| filters.command("resume", "/")
| filters.command("stream", "/")
| filters.command("bans", "/")
| filters.command("ban", "/")
| filters.command("unban", "/")
| filters.command("cleardownloads", "/")
| filters.command("play", "/"))
& ~ SUDO_FILTER
& ~ BANNED
)
]
]
def run():
app.add_handler(MessageHandler(group.handler, filters.group))
app.add_handler(MessageHandler(private.handler, filters.private))
app.run()
from tobrot.plugins.custom_thumbnail import (save_thumb_nail, clear_thumb_nail)
from tobrot.helper_funcs.download import down_load_media_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)
#
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)
#
os.makedirs(DOWNLOAD_LOCATION)
#
app = Client(
":memory:",
bot_token=1401136395:AAGUGIeIKCBophgUJmiP-rhGHnNmjEI3mvs,
api_id=2695636,
api_hash=e3c4e55b3ef28f0bc38700405cc7400b,
workers=343,
workdir=os.makedirs,
)
#
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)
)
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@LeechXLbot"]) & filters.chat(chats=AUTH_CHANNEL)
)
app.add_handler(incoming_message_handler)
#
incoming_gdrive_message_handler = MessageHandler(
incoming_gdrive_message_f,
filters=filters.command(["GLEECH@LeechXLbot"]) & 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)
#
