elif query.data == "skip":
player.STATE = State.Skipped
player.abort()
await query.message.edit_text(
f10(),
disable_web_page_preview=True,
reply_markup=rm()
)
await query.answer()
elif query.data == "pause":
if player.STATE == State.Paused:
player.STATE = State.Playing
elif player.STATE == State.Playing:
player.STATE = State.Paused
player.pause_resume()
await query.message.edit_text(
f10(),
disable_web_page_preview=True,
reply_markup=rm()
)
await query.answer()
__handlers__ = [
[
CallbackQueryHandler(
callback
)
]
]
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
incoming_banned_command = MessageHandler(
_banned_usrs,
filters=filters.command(["banned_users"]) & filters.user(AUTH_USERS)
& filters.reply)
app.add_handler(incoming_banned_command)
# BROADCAST Admin Command
incoming_broadcast_command = MessageHandler(
broadcast_,
filters=filters.command(["broadcast"]) & filters.user(AUTH_USERS)
& filters.reply)
app.add_handler(incoming_broadcast_command)
call_back_button_handler = CallbackQueryHandler(button)
app.add_handler(call_back_button_handler)
# run the APPlication
app.run()
InlineKeyboardButton("➕", callback_data="increase_volume"),
]]),
quote=False,
)
await query.message.delete()
await query.answer()
elif query.data == "increase_volume":
volume = current_volume + 1
if volume > 100:
volume = 100
volume = f"{volume}%"
await asyncio.create_subprocess_exec(
["pactl", "set-sink-volume", "MySink", volume]).wait()
await query.message.reply_text(
_("current_volume").format(volume),
reply_markup=InlineKeyboardMarkup([[
InlineKeyboardButton("➖", callback_data="decrease_volume"),
InlineKeyboardButton("➕", callback_data="increase_volume"),
]]),
quote=False,
)
await query.message.delete()
await query.answer()
__handlers__ = [[CallbackQueryHandler(callback)]]
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 hr(c, m):
asyncio.create_task(dump(), name="dumper")
async def stop(c, m):
h = asyncio.all_tasks()
dumper = [task for task in h if task.get_name() == "dumper"][0]
dumper.cancel()
app.id = 19
app.add_handler(
MessageHandler(callback=sync, filters=filters.command(["sync"])))
app.add_handler(
MessageHandler(callback=sync_cancel, filters=filters.command(["cancel"])))
app.add_handler(
MessageHandler(callback=timetable, filters=filters.command(["timetable"])))
app.add_handler(
MessageHandler(callback=close_session, filters=filters.command(["close"])))
app.add_handler(
MessageHandler(callback=toolkit, filters=filters.command(["screenshot"])))
app.add_handler(
MessageHandler(callback=send_message, filters=filters.command(["send"])))
app.add_handler(
MessageHandler(callback=toolkit, filters=filters.command(["mute"])))
app.add_handler(CallbackQueryHandler(callback_handler))
app.add_handler(DisconnectHandler(disconnect_handler))
app.add_handler(MessageHandler(recv))
app.run()
async def start(self):
await super().start()
usr_bot_me = await self.get_me()
# create download directory, if not exist
if not os.path.isdir(DOWNLOAD_LOCATION):
os.makedirs(DOWNLOAD_LOCATION)
LOGGER(__name__).info("@PublicLeechGroup, trying to add handlers")
# PURGE command
self.add_handler(
MessageHandler(incoming_purge_message_f,
filters=filters.command([Commandi.PURGE])
& filters.chat(chats=AUTH_CHANNEL)))
# STATUS command
self.add_handler(
MessageHandler(status_message_f,
filters=filters.command([Commandi.STATUS])
& filters.chat(chats=AUTH_CHANNEL)))
# CANCEL command
self.add_handler(
MessageHandler(cancel_message_f,
filters=filters.command([Commandi.CANCEL])
& filters.chat(chats=AUTH_CHANNEL)))
if not SHOULD_USE_BUTTONS:
LOGGER(__name__).info("using COMMANDi mode")
# LEECH command
self.add_handler(
MessageHandler(leech_commandi_f,
filters=filters.command([Commandi.LEECH])
& filters.chat(chats=AUTH_CHANNEL)))
# YTDL command
self.add_handler(
MessageHandler(incoming_youtube_dl_f,
filters=filters.command([Commandi.YTDL])
& filters.chat(chats=AUTH_CHANNEL)))
else:
LOGGER(__name__).info("using BUTTONS mode")
# all messages filter
# in the AUTH_CHANNELs
self.add_handler(
MessageHandler(incoming_message_f,
filters=message_fliter
& filters.chat(chats=AUTH_CHANNEL)))
# button is LEGACY command to handle
# the OLD YTDL buttons,
# and also the new SUB buttons
self.add_handler(CallbackQueryHandler(button))
if DIS_ABLE_ST_GFC_COMMAND_I:
self.add_handler(
MessageHandler(exec_message_f,
filters=filters.command([Commandi.EXEC])
& filters.user(users=SUDO_USERS)))
self.add_handler(
MessageHandler(eval_message_f,
filters=filters.command([Commandi.EVAL])
& filters.user(users=SUDO_USERS)))
# MEMEs COMMANDs
self.add_handler(
MessageHandler(upload_document_f,
filters=filters.command([Commandi.UPLOAD])
& filters.user(users=SUDO_USERS)))
# HELP command
self.add_handler(
MessageHandler(help_message_f,
filters=filters.command([Commandi.HELP])
& filters.chat(chats=AUTH_CHANNEL)))
# not AUTH CHANNEL users
self.add_handler(
MessageHandler(new_join_f,
filters=~filters.chat(chats=AUTH_CHANNEL)))
# welcome MESSAGE
self.add_handler(
MessageHandler(help_message_f,
filters=filters.chat(chats=AUTH_CHANNEL)
& filters.new_chat_members))
# savethumbnail COMMAND
self.add_handler(
MessageHandler(save_thumb_nail,
filters=filters.command([Commandi.SAVETHUMBNAIL])
& filters.chat(chats=AUTH_CHANNEL)))
# clearthumbnail COMMAND
self.add_handler(
MessageHandler(clear_thumb_nail,
filters=filters.command([Commandi.CLEARTHUMBNAIL])
& filters.chat(chats=AUTH_CHANNEL)))
# an probably easy way to get RClone CONF URI
self.add_handler(
MessageHandler(
save_rclone_conf_f,
filters=filters.command([Commandi.GET_RCLONE_CONF_URI])
& filters.user(users=SUDO_USERS)))
# Telegram command to upload LOG files
self.add_handler(
MessageHandler(upload_log_file,
filters=filters.command([Commandi.UPLOAD_LOG_FILE])
& filters.user(users=SUDO_USERS)))
LOGGER(__name__).info(
f"@{usr_bot_me.username} based on Pyrogram v{__version__} ")
await on_join(group_call.call)
elif participant.left:
await on_left(group_call.call)
break
raise ContinuePropagation
@call.on_stream_end()
async def _stream_end_handler(_: PyTgCalls, update: Update):
if isinstance(update, StreamAudioEnded):
Dynamic.PLAYING = False
await skip_song()
@call.on_participants_change()
async def _participants_change_handler(_: PyTgCalls, update: Update):
if isinstance(update, JoinedGroupCallParticipant):
GROUP_CALL_PARTICIPANTS.append(update.participant.user_id)
elif isinstance(update, LeftGroupCallParticipant):
GROUP_CALL_PARTICIPANTS.remove(update.participant.user_id)
if userge.has_bot:
userge.bot.add_handler(
CallbackQueryHandler(vc_callback, filters.regex("(skip|queue|back$)")))
userge.bot.add_handler(
CallbackQueryHandler(vol_callback, filters.regex(r"vol\((.+)\)")))
userge.bot.add_handler(
CallbackQueryHandler(vc_control_callback,
filters.regex("(player|seek|rewind|replay)")))
MessageHandler(speedtestxyz,
custom_filters.command('speedtest') & filters.user(SUDO)),
MessageHandler(evaluate,
custom_filters.command('py') & filters.user(SUDO)),
MessageHandler(terminal,
custom_filters.command('exec') & filters.user(SUDO)),
MessageHandler(invite_link, custom_filters.command('invitelink')),
MessageHandler(paste, custom_filters.command('paste')),
MessageHandler(translate, custom_filters.command('tr')),
MessageHandler(echo_message,
custom_filters.command('echo') & filters.user(SUDO)),
MessageHandler(ping_bot,
custom_filters.command('ping') & filters.user(SUDO)),
MessageHandler(report_setting, custom_filters.command("reporting")),
MessageHandler(report, filters.group & custom_filters.command('report')),
CallbackQueryHandler(buttons, filters.regex(r"rp_")),
MessageHandler(set_flood,
custom_filters.command('setflood') & ~filters.private),
MessageHandler(flood,
custom_filters.command('flood') & ~filters.private),
MessageHandler(runs,
custom_filters.command('runs') & ~filters.private),
MessageHandler(slap,
custom_filters.command('slap') & ~filters.private),
MessageHandler(cleaner_setting,
custom_filters.command('cleanbluetext') & ~filters.private),
MessageHandler(bluetextclean, filters.text & ~filters.private)
]
for handler in handlers:
butler.add_handler(handler)
from MeguRobot.utils import filters
from pyrogram.handlers import CallbackQueryHandler, MessageHandler
handlers = [
MessageHandler(whois, filters.command("whois")),
MessageHandler(telegraph, filters.command("telegraph")),
MessageHandler(google_rs, filters.command("reverse")),
MessageHandler(lookup, filters.command("spbinfo")),
MessageHandler(usage,
filters.command("usage") & filters.dev),
MessageHandler(whatanime, filters.command("whatanime")),
MessageHandler(purge_messages,
filters.command("purge") & filters.admin),
MessageHandler(delete_message,
filters.command("del") & filters.admin),
CallbackQueryHandler(downanime, filters.regex("^downanime_.*$")),
CallbackQueryHandler(search_episodes, filters.regex("^title_.*$")),
CallbackQueryHandler(confirm_dowload, filters.regex("^episode_.*$")),
CallbackQueryHandler(download_episode, filters.regex("^download_.*$")),
MessageHandler(anime_airing, filters.command("airing")),
MessageHandler(anime_search, filters.command("anime")),
MessageHandler(character_search, filters.command("character")),
MessageHandler(manga_search, filters.command("manga")),
MessageHandler(paste, filters.command("paste")),
MessageHandler(get_paste_, filters.command("gpaste")),
MessageHandler(set_user, filters.command("setuser")),
MessageHandler(clear_user, filters.command("clearuser")),
MessageHandler(last_fm, filters.command("lastfm")),
CallbackQueryHandler(get_yt, filters.regex("^get_music_.*$")),
MessageHandler(upcoming, filters.command("upcoming")),
CallbackQueryHandler(upcoming_buttons, filters.regex("^upcoming_.*$")),
