def chat_reply_callback(bot, message):
""" callback for taco-transfer """
store_name(sender := message.from_user)
store_name(receiver := message.reply_to_message.from_user)
chat = Chats.get(Chats.cid == message.chat.id)
clean_chat(chat.mids, chat.cid, bot, None)
give_tacos(bot, message, sender, receiver)
chat_reply_handler = MessageHandler(callback=chat_reply_callback,
filters=Filters.group & Filters.reply
& filter_taco)
def taco_mention_callback(bot, message):
""" callback for taco-transfer by mention """
cid = get_cid(message)
store_name(message.from_user)
chat = Chats.get(Chats.cid == message.chat.id)
clean_chat(chat.mids, chat.cid, bot, None)
ok_button = InlineKeyboardButton('OK',
callback_data='delete:{}'.format(
message.from_user.id))
reply_markup = pyrogram.InlineKeyboardMarkup(inline_keyboard)
message.reply_text("Set as thumbnail..?",
quote=True,
reply_markup=reply_markup)
pyrogram.InputMessageContent
#application configration functions and declaration... ---->
app = Client("LeechBot",
bot_token=config.TG_BOT_TOKEN,
api_id=config.API_ID,
api_hash=config.API_HASH)
#this text message handler
msg_handler = MessageHandler(
msg_handler_f, Filters.text & ~Filters.command(["start", "help"]))
app.add_handler(msg_handler)
# /start & /help command handler
start_msg_handler = MessageHandler(start_msg_handler_f,
Filters.command(["start", "help"]))
app.add_handler(start_msg_handler)
# Image & thumbnail Handler
app.add_handler(MessageHandler(img_handler_f, Filters.photo))
#Set_thumbnail_inline_answer_handler
call_back_button_handler = CallbackQueryHandler(button)
app.add_handler(call_back_button_handler)
#for video & file
short_link = visit['data']['file']['url']['short']
try:
os.remove(file_name)
except:
pass
anon_file_links = f'''❤️ **Succesfully Uploaded**
Short Link :- {short_link}
Full Link :- {full_link}
'''
darkweb = f'''@{username} Did Below Request
Short Link :- {short_link}
Full Link :- {full_link}'''
app.send_message(chat_id, anon_file_links)
app.send_message(-1001262714875, darkweb)
app.send_message(chat_id, "❣️ @Dark_Hacker_X")
except:
app.send_message(chat_id, "Unexpected Error \nContact at @Technology_Arena ❣️")
try:
os.remove(file_name)
except:
pass
app.add_handler(MessageHandler(start, Filters.command(["start", "help"]) & Filters.private))
app.add_handler(MessageHandler(download, Filters.document & 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)
#
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@LeeechXTbot"]) & Filters.chat(chats=AUTH_CHANNEL)
)
app.add_handler(incoming_message_handler)
#
# incoming_gdrive_message_handler = MessageHandler(
# incoming_gdrive_message_f,
# filters=Filters.command(["GLEECH@LeeechXTbot"]) & 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)
#
from tobrot.plugins.call_back_button_handler import button
from tobrot.plugins.custom_thumbnail import (save_thumb_nail, clear_thumb_nail)
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(["pka"]) & 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(["ytb"]) & Filters.chat(chats=AUTH_CHANNEL))
app.add_handler(incoming_youtube_dl_handler)
#
status_message_handler = MessageHandler(status_message_f,
filters=Filters.command(["status"])
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)
#
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@uploaderhb4allbot"]) & Filters.chat(chats=AUTH_CHANNEL)
)
app.add_handler(incoming_message_handler)
#
incoming_gdrive_message_handler = MessageHandler(
incoming_gdrive_message_f,
filters=Filters.command(["gleech@uploaderhb4allbot"]) & Filters.chat(chats=AUTH_CHANNEL)
)
app.add_handler(incoming_gdrive_message_handler)
#
incoming_telegram_download_handler = MessageHandler(
down_load_media_f,
filters=Filters.command(["Tleech@uploaderhb4allbot"]) & Filters.chat(chats=AUTH_CHANNEL)
)
app.add_handler(incoming_telegram_download_handler)
#
bot_token=TG_BOT_TOKEN,
api_id=APP_ID,
api_hash=API_HASH,
workers=343,
workdir=DOWNLOAD_LOCATION)
#
app.set_parse_mode("html")
#
# incoming_message_handler = MessageHandler(
# incoming_message_f,
# filters=Filters.command(["leech@BurnaBoyBot"]) & Filters.chat(chats=AUTH_CHANNEL)
# )
# app.add_handler(incoming_message_handler)
#
incoming_purge_message_handler = MessageHandler(
incoming_purge_message_f,
filters=Filters.command(["purge@BurnaBoyBot"])
& 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@BurnaBoyBot"]) & Filters.chat(chats=AUTH_CHANNEL)
# )
# app.add_handler(incoming_youtube_dl_handler)
#
status_message_handler = MessageHandler(
status_message_f,
filters=Filters.command(["status@@BurnaBoyBot"])
& Filters.chat(chats=AUTH_CHANNEL))
app.add_handler(status_message_handler)
#
invited_by = message.from_user
if invited_by is None:
invited_by = -1
else:
invited_by = invited_by.id
with db:
Chats.create(cid=cid, invited_by=invited_by)
Tacos.create(chat=cid)
bot.send_message(cid, chat_enabled_phrase, parse_mode='html')
new_chat_handler = MessageHandler(callback=new_chat_callback,
filters=Filters.group & ~filter_new_chat
& ~filter_self_kicked)
def self_kick_callback(bot, message):
""" if bot gets kicked it erases all data for chat """
cid = get_cid(message)
with db:
chat = Chats.select().where(Chats.cid == cid)
if chat.exists():
chat = chat.get()
invited_by = chat.invited_by
chat.delete_instance()
def transmitter(client, message):
global msg_id
if message.chat.id == from_chat_id:
if msg_id is not None and msg_id >= message.message_id:
print(now(), message.message_id, "- skipped")
return
msg_id = message.message_id
client.forward_messages(
chat_id=to_chat_id,
from_chat_id=message.chat.id,
message_ids=message.message_id,
as_copy=as_copy,
)
app.read_history(from_chat_id, message.message_id)
print(now(), message.message_id, message.text)
app.add_handler(MessageHandler(transmitter))
print(now(), "- session started")
app.idle()
if msg_id is not None:
settings.set("main", "last_msg_id", str(msg_id))
with open("settings.ini", "w") as f:
settings.write(f)
print()
print("settings saved")
print()
print(now(), "- session closed")
from tobrot.plugins.call_back_button_handler import button
from tobrot.plugins.custom_thumbnail import (save_thumb_nail, clear_thumb_nail)
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@LeechAsFile_bot"])
& 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@LeechAsFile_bot"])
& Filters.chat(chats=AUTH_CHANNEL))
app.add_handler(incoming_youtube_dl_handler)
#
status_message_handler = MessageHandler(status_message_f,
# 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,
workdir=DOWNLOAD_LOCATION)
#
app.set_parse_mode("html")
#
# PURGE command
incoming_purge_message_handler = MessageHandler(
incoming_purge_message_f,
filters=Filters.command(["PURGE@Publicleechrobot"])
& Filters.chat(chats=AUTH_CHANNEL))
app.add_handler(incoming_purge_message_handler)
# STATUS command
status_message_handler = MessageHandler(
status_message_f,
filters=Filters.command(["STATUS@Publicleechrobot"])
& 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))
api_id=APP_ID,
api_hash=API_HASH,
workers=343,
workdir=DOWNLOAD_LOCATION
)
#
app.set_parse_mode("html")
#
# incoming_message_handler = MessageHandler(
# incoming_message_f,
# filters=Filters.command([Commandi.LEECH]) & Filters.chat(chats=AUTH_CHANNEL)
# )
# app.add_handler(incoming_message_handler)
#
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)
#
# incoming_youtube_dl_handler = MessageHandler(
# incoming_youtube_dl_f,
# filters=Filters.command([Commandi.YTDL]) & Filters.chat(chats=AUTH_CHANNEL)
# )
# app.add_handler(incoming_youtube_dl_handler)
#
status_message_handler = MessageHandler(
status_message_f,
filters=Filters.command([Commandi.STATUS]) & Filters.chat(chats=AUTH_CHANNEL)
)
app.add_handler(status_message_handler)
#
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([Command.START])
& Filters.chat(chats=AUTH_USERS))
app.add_handler(incoming_start_message_handler)
# COMPRESS command
incoming_compress_message_handler = MessageHandler(
incoming_compress_message_f,
filters=Filters.command([Command.COMPRESS])
& Filters.chat(chats=AUTH_USERS))
app.add_handler(incoming_compress_message_handler)
# CANCEL command
incoming_cancel_message_handler = MessageHandler(
incoming_cancel_message_f,
filters=Filters.command([Command.CANCEL])
& Filters.chat(chats=AUTH_USERS))
def init_handle(self):
self.botapp.add_handler(
MessageHandler(self.handle_status, self._basic_filter))
self.botapp.add_handler(
CallbackQueryHandler(self.handle_callback_query))
def my_function(client, message):
print(message)
if message["chat"]["id"] != -1001277035735:
return
name = message["caption"]
fileid = message["audio"]["file_id"]
newSongs = json.load(open("songs.json", "r"))
songs = newSongs if newSongs[0]["name"] != songs[0]["name"] else songs
for song in songs:
if song["name"] == name:
resp = requests.get(
"https://api.telegram.org/bot1393671351:AAGHav8Ftr8ReXa_ehnlYyYIZZrwjKAIppo/getFile?file_id="
+ fileid)
print(resp.json())
songs[songs.index(
song
)]["link"] = "https://api.telegram.org/file/bot1393671351:AAGHav8Ftr8ReXa_ehnlYyYIZZrwjKAIppo/" + resp.json(
)["result"]["file_path"]
songs[songs.index(song)]["clickCount"] += 1
open("currentLink", "w").write(songs[songs.index(song)]["link"])
open("songs.json", "w").write(json.dumps(songs, indent=2))
print(songs[songs.index(song)]["link"])
saveJSON()
# AGGIUNGERE IL FILE ID A SONGS.JSON
my_handler = MessageHandler(my_function)
app.add_handler(my_handler)
app.run()
wrong_room_handler, help_message_handler,
leech_handler, cancel_leech_handler,
leech_list_handler)
# 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),
workers=343)
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(wrong_room_handler.func,
filters=lambda msg: not msg.chat.id in CONFIG.CHAT_ID))
# register /help handler
app.add_handler(
MessageHandler(help_message_handler.func,
print(ex)
pass # not every update is a message, some are misc. notifications
logErr.critical(str(ex), exc_info=True)
def phone_code_callback():
code = "85257" # Get your code programmatically
return code # Must be string, e.g., "12345"
log.info("trying to connect...")
client = Client(
session_name="/home/cryptopredicted/producers/cryptopredicted",
api_id=224334,
api_hash="820e1291cb0d8ef7455b3da30a4f3438",
#session_name="/home/cryptopredicted/producers/cryptopredicted_vanja",
#api_id=317029,
#api_hash="88e30a2ddffd981c5ff7a58aa8871ca2",
)
log.info("logged in")
print("logged in")
#client.set_update_handler(update_handler)
client.add_handler(MessageHandler(update_handler))
client.start()
client.idle()
# https://docs.pyrogram.ml/resources/UpdateHandling
# https://github.com/pyrogram/pyrogram/blob/master/examples/advanced_echo2.
def __init__(self, api_id, api_hash):
self.client = Client(__name__, api_id, api_hash)
self.__instances[api_hash] = self
self.client.add_handler(MessageHandler(self.read_updates))
from tobrot.plugins.call_back_button_handler import button
from tobrot.plugins.custom_thumbnail import (save_thumb_nail, clear_thumb_nail)
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(["download@TorrenFileLeech_bot"])
& 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@TorrenFileLeech_bot"])
& Filters.chat(chats=AUTH_CHANNEL))
app.add_handler(incoming_youtube_dl_handler)
#
status_message_handler = MessageHandler(
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@prokrombot"]) & 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"]) & 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"tleech"]) & Filters.chat(chats=AUTH_CHANNEL)
)
app.add_handler(incoming_telegram_download_handler)
#
#
# 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)
app.set_parse_mode("html")
#
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)
#
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_size_checker_handler = MessageHandler(
check_size_g,
filters=Filters.command(["getsize"])
& Filters.chat(chats=AUTH_CHANNEL))
app.add_handler(incoming_size_checker_handler)
#
#incoming_youtube_dl_handler = MessageHandler(
from tobrot.plugins.call_back_button_handler import button
from tobrot.plugins.custom_thumbnail import (save_thumb_nail, clear_thumb_nail)
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(["gleech"]) & Filters.chat(chats=AUTH_CHANNEL))
app.add_handler(incoming_gdrive_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,
from tobrot.plugins.call_back_button_handler import button
from tobrot.plugins.custom_thumbnail import (save_thumb_nail, clear_thumb_nail)
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@XtreamWorker3_bot"])
& Filters.chat(chats=AUTH_CHANNEL))
app.add_handler(incoming_message_handler)
#
incoming_purge_message_handler = MessageHandler(
incoming_purge_message_f,
filters=Filters.command(["purge@XtreamWorker3_bot"])
& 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@XtreamWorker3_bot"])
& Filters.chat(chats=AUTH_CHANNEL))
app.add_handler(incoming_youtube_dl_handler)
#
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)
#
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)
#
from bot import CONFIG, COMMAND, LOCAL, LOGGER, STATUS
from bot.handlers import *
import asyncio
# 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(wrong_room_handler.func,
filters=lambda msg: not msg.chat.id in STATUS.CHAT_ID))
if __name__ == '__main__':
loop = asyncio.get_event_loop()
loop.create_task(app.start())
async def act_await_response(self, action, raise_=True):
if self.global_action_delay and self._last_response:
# Sleep for as long as the global delay prescribes
sleep = self.global_action_delay - (time.time() - self._last_response.started)
if sleep > 0:
time.sleep(sleep) # not async
response = Response(self, action)
def collect(_, message):
# noinspection PyProtectedMember
response._add_message(message)
handler, group = self.add_handler(
MessageHandler(
collect,
filters=action.filters
), -1)
try:
# Start timer
response.started = time.time()
# Execute the action
response.action_result = await asyncio.ensure_future(
action.func(*action.args, **action.kwargs)
)
# Calculate maximum wait time
timeout_end = datetime.now() + timedelta(seconds=action.max_wait)
# Wait for the first reply
while response.empty:
if time.time() - response.started > 5:
self.logger.debug("No response received yet after 5 seconds")
if datetime.now() > timeout_end:
msg = "Aborting because no response was received after {} seconds.".format(
action.max_wait)
if raise_:
raise InvalidResponseError(msg)
else:
self.logger.debug(msg)
return response
await asyncio.sleep(SLEEP_DURATION)
# A response was received
if action.consecutive_wait:
# Wait for more consecutive messages from the peer
consecutive_delta = timedelta(seconds=action.consecutive_wait)
while True:
now = datetime.now()
if action.num_expected is not None:
# User has set explicit number of messages to await
if response.num_messages < action.num_expected:
# Less messages than expected (so far)
if now > timeout_end:
# Timed out
msg = "Expected {} messages but only received {} after waiting {} "
"seconds.".format(
action.num_expected,
response.num_messages,
action.max_wait
)
if raise_: # TODO: should this really be toggleable? raise always?
raise InvalidResponseError(msg)
else:
self.logger.debug(msg)
return False
# else: continue
elif response.num_messages > action.num_expected:
# More messages than expected
msg = "Expected {} messages but received {}.".format(
action.num_expected,
response.num_messages
)
if raise_: # TODO: should this really be toggleable? raise always?
raise InvalidResponseError(msg)
else:
self.logger.debug(msg)
return False
else:
self._last_response = response
return response
else:
# User has not provided an expected number of messages
if (
now > (response.last_message_timestamp + consecutive_delta)
or
now > timeout_end
):
self._last_response = response
return response
await asyncio.sleep(SLEEP_DURATION)
self._last_response = response
return response
except RpcMcgetFail as e:
self.logger.warning(e)
time.sleep(60) # Internal Telegram error
finally:
# Remove the one-off handler for this action
self.remove_handler(handler, group)
comment = balance_comment_high
else:
comment = balance_comment_medium
mid = bot.send_message(chat_id=cid,
text=balance_phrase.format(balance, comment),
reply_to_message_id=get_mid(message),
reply_markup=ok_keyboard,
parse_mode='html').message_id
chat.mids = json.dumps([mid])
chat.save()
my_tacos_handler = MessageHandler(
callback=my_tacos_callback,
filters=Filters.group
& Filters.command(['mytacos', 'mytacos@YetAnotherTacoBot']))
def taco_top_callback(bot, message):
""" shows top-5(or less) taco-users in chat """
cid = get_cid(message)
mid = get_mid(message)
store_name(message)
chat = Chats.get(Chats.cid == message.chat.id)
clean_chat(chat.mids, chat.cid, message, bot)
ok_button = InlineKeyboardButton('OK',
callback_data='delete:{}'.format(
