def main():
log_file = init_logger()
config.load_config()
config.LOG_FILE = log_file
telegram_pickle = PicklePersistence(filename='pickle_{}'.format(
config.USER_IDS[0]),
store_bot_data=True,
store_user_data=True,
store_chat_data=False)
q = mq.MessageQueue()
request = TGRequest(con_pool_size=8)
my_bot = MQBot(config.TELEGRAM_TOKEN, request=request, mqueue=q)
updater = Updater(bot=my_bot,
use_context=True,
persistence=telegram_pickle)
updater.dispatcher.add_error_handler(error)
load_handlers(updater.dispatcher)
updater.start_polling()
updater.bot.send_message(chat_id=config.USER_IDS[0],
text='Telegram gcloner first call, start.')
updater.idle()
def main():
log_file = init_logger()
config.load_config()
config.LOG_FILE = log_file
telegram_pickle = PicklePersistence(filename='pickle_{}'.format(
config.USER_IDS[0]),
store_bot_data=True,
store_user_data=True,
store_chat_data=False)
q = mq.MessageQueue()
request = TGRequest(con_pool_size=8)
my_bot = MQBot(config.TELEGRAM_TOKEN, request=request, mqueue=q)
updater = Updater(bot=my_bot,
use_context=True,
persistence=telegram_pickle)
updater.dispatcher.add_error_handler(error)
load_handlers(updater.dispatcher)
updater.start_polling()
updater.bot.send_message(
chat_id=config.USER_IDS[0],
text='β‘οΈ ππππππ΅ππ"πΆ π½πΕ ππππΉπΎππΎπ. π΅πΆπΔ± ππππΎππππΎ πππ
ππΆππΆππΆπΔ±π !')
updater.idle()
def simple_size(update, context, item, size_chat_id, size_message_id, share_name_list):
request = TGRequest(con_pool_size=8)
bot = Bot(token=f"{_cfg['tg']['token']}", request=request)
cloner = _cfg["general"]["cloner"]
option = "size"
remote = _cfg["general"]["remote"]
src_id = item
src_block = remote + ":" + "{" + src_id + "}"
checkers = "--checkers=" + f"{_cfg['general']['parallel_c']}"
flags = ['--size-only']
sa_sleep = "--drive-pacer-min-sleep=" + f"{_cfg['general']['min_sleep']}"
command = [cloner, option, src_block, checkers, sa_sleep]
command += flags
simple_size_process(command, bot, size_chat_id, size_message_id, share_name_list)
def main():
### bot define
request = TGRequest(con_pool_size=8)
bot = Bot(token=f"{load.cfg['tg']['token']}", request=request)
updater = Updater(bot=bot, use_context=True)
### judge is restart
is_restart = load.db_counters.find_one({"_id": "is_restart"})
if is_restart is not None:
if is_restart["status"] == 0:
pass
else:
_func.check_restart(bot)
else:
load.db_counters.update(
{"_id": "is_restart"},
{"status": 0},
upsert=True,
)
dp = updater.dispatcher
# Entry Conversation
conv_handler = ConversationHandler(
entry_points=[
# Entry Points
CommandHandler("set", _set._setting),
CommandHandler("menu", _start.menu),
CommandHandler("quick", _quick.quick),
CommandHandler("copy", _copy.copy),
CommandHandler("task", _box.taskinfo),
CommandHandler("size", _size.size),
CommandHandler("purge", _purge.purge),
CommandHandler("dedupe", _dedupe.dedupe),
MessageHandler(Filters.regex(pattern=load.regex_entry_pattern),
_regex.regex_entry),
],
states={
_stage.SET_FAV_MULTI: [
# fav settings function
MessageHandler(Filters.text, _set._multi_settings_recieved),
],
_stage.CHOOSE_MODE: [
# call function judged via callback pattern
CallbackQueryHandler(_quick.quick, pattern="quick"),
CallbackQueryHandler(_copy.copy, pattern="copy"),
],
_stage.GET_LINK: [
# get Shared_Link states
MessageHandler(Filters.text, _func.get_share_link),
],
_stage.IS_COVER_QUICK: [
# cover quick setting
CallbackQueryHandler(_func.modify_quick_in_db,
pattern="cover_quick"),
CallbackQueryHandler(_func.cancel, pattern="not_cover_quick"),
MessageHandler(Filters.text, _func.cancel),
],
_stage.GET_DST: [
# request DST
CallbackQueryHandler(_copy.request_srcinfo),
],
_stage.COOK_ID: [
# request to COOK ID
MessageHandler(Filters.text, _size.size_handle),
],
_stage.REGEX_IN: [
# regex in choose mode
CallbackQueryHandler(_regex.regex_callback,
pattern=r"quick|copy|size"),
],
_stage.REGEX_GET_DST: [
# regex copy end
CallbackQueryHandler(_regex.regex_copy_end),
],
_stage.COOK_FAV_TO_SIZE: [
CallbackQueryHandler(_size.pre_cook_fav_to_size),
],
_stage.COOK_FAV_PURGE: [
CallbackQueryHandler(_purge.pre_to_purge),
],
_stage.COOK_ID_DEDU: [
CallbackQueryHandler(_dedupe.dedupe_mode),
],
_stage.COOK_FAV_DEDU: [
CallbackQueryHandler(_dedupe.dedupe_fav_mode),
],
_stage.FAV_PRE_DEDU_INFO:
[CallbackQueryHandler(_dedupe.pre_favdedu_info)],
},
fallbacks=[CommandHandler("cancel", _func.cancel)],
)
def stop_and_restart():
progress.terminate()
load.myclient.close()
updater.stop()
os.execl(sys.executable, sys.executable, *sys.argv)
def restart(update, context):
restart_msg = update.message.reply_text(
load._text[load._lang]["is_restarting"])
restart_chat_id = restart_msg.chat_id
restart_msg_id = restart_msg.message_id
load.db_counters.update_one(
{"_id": "is_restart"},
{
"$set": {
"status": 1,
"chat_id": restart_chat_id,
"message_id": restart_msg_id,
}
},
True,
)
Thread(target=stop_and_restart).start()
dp.add_handler(conv_handler)
dp.add_handler(CommandHandler("start", _start.start))
dp.add_handler(CommandHandler("reset", _box.task_reset))
dp.add_handler(CommandHandler("kill", _func.taskill))
dp.add_handler(CommandHandler("ver", _func._version))
dp.add_handler(
CommandHandler(
"restart",
restart,
filters=Filters.user(user_id=int(load.cfg["tg"]["usr_id"])),
))
dp.add_error_handler(_func.error)
updater.start_polling()
logger.info("Fxxkr LAB iCopy " + __version__.__version__ + " Start")
updater.idle()
from telegram import ParseMode
from telegram.utils.request import Request as TGRequest
from telegram import Bot
myclient = pymongo.MongoClient(
f"{load.cfg['database']['db_connect_method']}://{load.user}:{load.passwd}@{load.cfg['database']['db_addr']}",
port=load.cfg["database"]["db_port"],
connect=False,
)
mydb = myclient[load.cfg["database"]["db_name"]]
task_list = mydb["task_list"]
db_counters = mydb["counters"]
_cfg = load.cfg
request = TGRequest(con_pool_size=8)
bot = Bot(token=f"{_cfg['tg']['token']}", request=request)
message_info = ""
prog_bar = ""
current_working_file = ""
old_working_file = ""
now_elapsed_time = ""
context_old = ""
icopyprocess = subprocess.Popen
interruption = 0
dst_id = ""
src_name = ""
def task_buffer(ns):
def task_process(chat_id, command, task, ns):
# mark is in processing in db
task_list.update_one({"_id": task["_id"]}, {"$set": {
"status": 2,
}})
request = TGRequest(con_pool_size=8)
bot = Bot(token=f"{_cfg['tg']['token']}", request=request)
chat_id = chat_id
message = bot.send_message(chat_id=chat_id,
text=_text[_lang]["ready_to_task"])
message_id = message.message_id
interval = 0.1
timeout = 60
xtime = 0
old_working_line = 0
current_working_line = 0
task_current_prog_num = 0
task_total_prog_num = 0
task_percent = 0
task_current_prog_size = "0"
task_total_prog_size = "0 Bytes"
task_in_size_speed = "-"
task_in_file_speed = "-"
task_eta_in_file = "-"
start_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
for toutput in run(command):
if ns.x == 1:
global icopyprocess
icopyprocess.kill()
regex_working_file = r"^ * "
regex_elapsed_time = r"^Elapsed time:"
regex_total_files = (
r"Transferred:\s+(\d+) / (\d+), (\d+)%(?:,\s*([\d.]+\sFiles/s))?")
regex_total_size = (
r"Transferred:[\s]+([\d.]+\s*[kMGTP]?) / ([\d.]+[\s]?[kMGTP]?Bytes),"
r"\s*(?:\-|(\d+)\%),\s*([\d.]+\s*[kMGTP]?Bytes/s),\s*ETA\s*([\-0-9hmsdwy]+)"
)
output = toutput
if output:
task_total_files = re.search(regex_total_files, output)
task_total_size = re.search(regex_total_size, output)
task_elapsed_time = re.findall(regex_elapsed_time, output)
task_working_file = re.findall(regex_working_file, output)
if task_total_files:
task_current_prog_num = task_total_files.group(1)
task_total_prog_num = task_total_files.group(2)
task_percent = int(task_total_files.group(3))
task_in_file_speed = task_total_files.group(4)
if task_total_size:
task_current_prog_size = task_total_size.group(1)
task_total_prog_size = task_total_size.group(2)
task_in_size_speed = task_total_size.group(4)
task_eta_in_file = task_total_size.group(5)
if task_elapsed_time:
global now_elapsed_time
now_elapsed_time = output.replace(" ", "").split(":")[1]
if task_working_file:
global current_working_file
current_working_line += 1
current_working_file = (
output.lstrip("* ").rsplit(":")[0].rstrip("Transferred"))
global prog_bar
prog_bar = _bar.status(0)
if task_percent != 0:
prog_bar = _bar.status(task_percent)
global message_info
message_info = (
_text[_lang]["task_src_info"] + "\n" + "π" + task["src_name"] +
"\n" + "----------------------------------------" + "\n" +
_text[_lang]["task_dst_info"] + "\n" + "π" + task["dst_name"] +
":" + "\n" + " ββπ" + task["src_name"] + "\n" +
"----------------------------------------" + "\n\n" +
_text[_lang]["task_start_time"] + start_time + "\n\n" +
_text[_lang]["task_files_size"] + str(task_current_prog_size) +
"/" + str(task_total_prog_size) + "\n" +
_text[_lang]["task_files_num"] + str(task_current_prog_num) + "/" +
str(task_total_prog_num) + "\n" + _text[_lang]["task_status"] +
"\n\n" + str(task_in_size_speed) + " | " +
str(task_in_file_speed) + "\n\n" + str(task_percent) + "%" +
str(prog_bar))
if (int(time.time()) - xtime > interval
and old_working_line != current_working_line):
Timer(
0,
task_message_box,
args=(
bot,
chat_id,
message_id,
" ΰΌΊ βͺiCopyβͺ ΰΌ» \n" + _text[_lang]["doing"] + " | " + "π³οΈ" +
_text[_lang]["current_task_id"] + str(task["_id"]) +
"\n\n" + message_info + "\n\n" +
current_working_file[:30] + "\n" + "ETA : " +
str(task_eta_in_file),
),
).start()
old_working_line = current_working_line
global old_working_file
old_working_file = current_working_file
time.sleep(3.5)
xtime = time.time()
if (int(time.time()) - xtime > timeout
and current_working_file == old_working_file
and task_percent > 5):
global interruption
interruption = 1
break
old_working_file = ""
finished_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
if ns.x == 0:
time.sleep(5)
prog_bar = _bar.status(100)
bot.edit_message_text(
chat_id=chat_id,
message_id=message_id,
text=" ΰΌΊ βͺiCopyβͺ ΰΌ» \n" + _text[_lang]["done"] + " | " + "π³οΈ" +
_text[_lang]["current_task_id"] + str(task["_id"]) + "\n\n" +
message_info + "\n" + _text[_lang]["task_finished_time"] +
finished_time + "\n" + _text[_lang]["elapsed_time"] +
str(now_elapsed_time),
)
task_list.update_one(
{"_id": task["_id"]},
{
"$set": {
"status": 1,
"start_time": start_time,
"finished_time": finished_time,
}
},
)
interrupted_msg = (
_text[_lang]["task_src_info"] + "\n" + "π" + task["src_name"] + "\n" +
"----------------------------------------" + "\n" +
_text[_lang]["task_dst_info"] + "\n" + "π" + task["dst_name"] + ":" +
"\n" + " ββπ" + task["src_name"] + "\n" +
"----------------------------------------" + "\n\n" +
_text[_lang]["task_files_size"] + str(task_current_prog_size) + "/" +
str(task_total_prog_size) + "\n" + _text[_lang]["task_files_num"] +
str(task_current_prog_num) + "/" + str(task_total_prog_num) + "\n\n" +
str(task_percent) + "%" + str(prog_bar))
if ns.x == 1:
bot.edit_message_text(
chat_id=chat_id,
message_id=message_id,
text=" ΰΌΊ βͺiCopyβͺ ΰΌ» \n" + _text[_lang]["killed"] + " | " + "π³οΈ" +
_text[_lang]["current_task_id"] + str(task["_id"]) + "\n\n" +
interrupted_msg + "\n" + _text[_lang]["is_killed_by_user"],
)
task_list.update_one({"_id": task["_id"]}, {
"$set": {
"status": 1,
"error": 9,
"start_time": start_time,
"finished_time": finished_time,
}
})
if interruption == 1:
bot.edit_message_text(
chat_id=chat_id,
message_id=message_id,
text=" ΰΌΊ βͺiCopyβͺ ΰΌ» \n" + _text[_lang]["interrupted"] + " | " +
"π³οΈ" + _text[_lang]["current_task_id"] + str(task["_id"]) +
"\n\n" + interrupted_msg + "\n" +
_text[_lang]["is_interrupted_error"],
)
task_list.update_one({"_id": task["_id"]}, {
"$set": {
"status": 1,
"error": 1,
"start_time": start_time,
"finished_time": finished_time,
}
})
prog_bar = _bar.status(0)
def main():
### bot define
request = TGRequest(con_pool_size=8)
bot = Bot(token=f"{load.cfg['tg']['token']}", request=request)
updater = Updater(bot=bot, use_context=True)
### judge is restart
is_restart = load.db_counters.find_one({"_id": "is_restart"})
if is_restart is not None:
if is_restart["status"] == 0:
pass
else:
_func.check_restart(bot)
else:
load.db_counters.update(
{"_id": "is_restart"},
{"status": 0},
upsert=True,
)
dp = updater.dispatcher
# Entry Conversation
conv_handler = ConversationHandler(
entry_points=[
# Entry Points
CommandHandler("set", _set._setting),
CommandHandler("menu", _start.menu),
CommandHandler("quick", _quick.quick),
CommandHandler("copy", _copy.copy),
CommandHandler("task", _box.taskinfo),
],
states={
_set.SET_FAV_MULTI: [
# fav settings function
MessageHandler(Filters.text, _set._multi_settings_recieved),
],
_start.CHOOSE_MODE: [
# call function judged via callback pattern
CallbackQueryHandler(_quick.quick, pattern="quick"),
CallbackQueryHandler(_copy.copy, pattern="copy"),
],
_quick.GET_LINK: [
# get Shared_Link states
MessageHandler(Filters.text, _func.get_share_link),
],
_set.IS_COVER_QUICK: [
# cover quick setting
CallbackQueryHandler(_func.modify_quick_in_db,
pattern="cover_quick"),
CallbackQueryHandler(_func.cancel, pattern="not_cover_quick"),
MessageHandler(Filters.text, _func.cancel),
],
_copy.GET_DST: [
# request DST
CallbackQueryHandler(_copy.request_srcinfo),
],
},
fallbacks=[CommandHandler("cancel", _func.cancel)],
)
def stop_and_restart():
progress.terminate()
load.myclient.close()
updater.stop()
os.execl(sys.executable, os.path.abspath(__file__), *sys.argv)
def restart(update, context):
restart_msg = update.message.reply_text(
load._text[load._lang]["is_restarting"])
restart_chat_id = restart_msg.chat_id
restart_msg_id = restart_msg.message_id
load.db_counters.update_one(
{"_id": "is_restart"},
{
"$set": {
"status": 1,
"chat_id": restart_chat_id,
"message_id": restart_msg_id,
}
},
True,
)
Thread(target=stop_and_restart).start()
dp.add_handler(conv_handler)
dp.add_handler(CommandHandler("start", _start.start))
dp.add_handler(CommandHandler("reset", _box.task_reset))
dp.add_handler(CommandHandler("kill", _func.taskill))
dp.add_handler(CommandHandler("ver", _func._version))
dp.add_handler(
CommandHandler(
"restart",
restart,
filters=Filters.user(user_id=int(load.cfg["tg"]["usr_id"])),
))
dp.add_error_handler(_func.error)
updater.start_polling()
logger.info(f"Fxxkr LAB iCopy {load._version} Start")
updater.idle()
