async def sideload(event):
if not getConfig("ALLOW_SIDELOAD"):
return
OVR_WRT_CAUT = True
cmd_args = event.pattern_match.group(1).split(" ", 1)
if cmd_args[0].lower() == "force":
OVR_WRT_CAUT = False
if event.reply_to_msg_id:
msg = await event.get_reply_message()
file = msg.file
if not file.name.endswith(".py"):
await event.edit(msgRep.NOT_PY_FILE)
return
dest_path = os.path.join(USER_MODULES_DIR, file.name)
await event.edit(msgRep.DLOADING)
if os.path.isfile(dest_path) and OVR_WRT_CAUT:
log.info(f"Module '{file.name[:-3]}' installed already")
await event.edit(msgRep.MODULE_EXISTS.format(file.name))
return
await event.client.download_media(message=msg, file=dest_path)
log.info(f"Module '{file.name[:-3]}' has been installed to userpace")
await event.edit(msgRep.SUCCESS.format(file.name))
if getConfig("LOGGING"):
await event_log(event,
"SIDELOAD",
custom_text=msgRep.LOG.format(file.name))
log.info("Rebooting userbot...")
time.sleep(1)
await event.edit(msgRep.RBT_CPLT)
setConfig("REBOOT", True)
await event.client.disconnect()
else:
await event.edit(msgRep.INVALID_FILE)
return
def check_reboot():
perf_reboot = getConfig("REBOOT", False)
start_recovery = getConfig("START_RECOVERY", False)
try:
if perf_reboot or start_recovery:
py_exec = (executable
if " " not in executable else '"' + executable + '"')
if perf_reboot: # preferred if True
if getConfig("REBOOT_SAFEMODE"):
log.info("Rebooting into safe mode...")
tcmd = [py_exec, "-m", "userbot", "-safemode"]
else:
log.info("Performing normal reboot...")
tcmd = [py_exec, "-m", "userbot"]
elif start_recovery:
commit_id = getConfig("UPDATE_COMMIT_ID")
if commit_id:
log.info("Starting auto update in recovery...")
tcmd = [py_exec, "recovery.py", "-autoupdate", commit_id]
else:
log.info("Rebooting into recovery...")
tcmd = [py_exec, "recovery.py"]
shutdown_logging()
execle(py_exec, *tcmd, environ)
except KeyboardInterrupt:
raise KeyboardInterrupt
except (BaseException, Exception) as e:
if start_recovery:
log.critical(f"Failed to reboot HyperUBot into recovery: {e}",
exc_info=True)
else:
log.critical(f"Failed to reboot HyperUBot: {e}",
exc_info=True)
return
async def kickme(leave):
await leave.edit(msgRep.LEAVING)
await leave.client.kick_participant(leave.chat_id, 'me')
if getConfig("LOGGING"):
await event_log(leave, "KICKME", chat_title=leave.chat.title,
chat_id=leave.chat.id)
return
async def outputAsFile(event, output_text) -> bool:
temp_file = path.join(getConfig("TEMP_DL_DIR"), "shell_output.txt")
try:
with open(temp_file, "w") as output_file:
output_file.write(output_text)
output_file.close()
except IOError as io:
log.warning(io, exc_info=True)
await event.edit(f"`{msgRep.BASH_CRT_FILE_FAILED_RO}`")
return
except Exception as e:
log.error(e, exc_info=True)
await event.edit(f"`{msgRep.BASH_CRT_FILE_FAILED}`")
return
try:
await event.client.send_file(event.chat_id, temp_file)
await event.delete() # delete message (not output file)
except ChatSendMediaForbiddenError:
log.warning(
f"[Shell] Send media is not allowed in chat '{event.chat_id}'")
await event.edit(f"`{msgRep.BASH_SEND_FILE_MTLO}`")
except Exception as e:
log.error(e, exc_info=True)
await event.edit(f"`{msgRep.BASH_SEND_FILE_FAILED}`")
remove(temp_file)
return
def modules_listing(error_text: str = None) -> str:
modules_listed = f"**Modules**\n\n"
if error_text:
modules_listed += f"{error_text}\n\n"
modules_listed += f"{msgRep.USAGE}:\n`.modules -d, --desc [{msgRep.NUMBER_OF_MODULE}]`\n"\
f"`.modules -i, --info [{msgRep.NUMBER_OF_MODULE}]`\n"\
f"`.modules -u, --usage [{msgRep.NUMBER_OF_MODULE}]`\n\n"
sys_count, user_count = installed_modules()
modules_listed += f"`{msgRep.SYSTEM_MODULES}: {sys_count}`\n"
modules_listed += f"`{msgRep.USER_MODULES}: {user_count}`\n\n" if not SAFEMODE else "\n"
modules_listed += f"{msgRep.AVAILABLE_MODULES}:\n"
modules_list = update_list()
all_running = all(ir == True for ir in [modules[-1] for modules in modules_list])
num = 0
warning = u"\u26A0" # warn emoji
user_modules = getUserModules()
for module_name, module, isRunning in modules_list:
num += 1
if module in user_modules:
if isRunning:
modules_listed += f"`({str(num)}) {module_name}* ({module})`\n"
else:
modules_listed += f"`({str(num)}) {module_name}* ({module}) {warning}`\n"
else:
if isRunning:
modules_listed += f"`({str(num)}) {module_name} ({module})`\n"
else:
modules_listed += f"`({str(num)}) {module_name} ({module}) {warning}`\n"
not_load_modules = getConfig("NOT_LOAD_MODULES")
if not_load_modules:
all_modules = getAllModules()
for module in not_load_modules:
if module in module:
modules_listed += "\n"
modules_listed += f"{msgRep.DISABLED_MODULES}:\n"
break
for module in sorted(not_load_modules):
if module in module:
if module in user_modules:
modules_listed += f"`- {module}*`\n"
else:
modules_listed += f"`- {module}`\n"
num += 1
if (user_modules and not SAFEMODE) or not all_running:
modules_listed += "--------------------------------\n"
if user_modules and not SAFEMODE:
modules_listed += f"__* = {msgRep.ASTERISK}__\n"
if not all_running:
modules_listed += f"__{warning} = {msgRep.NOT_RUNNING_INFO}__\n"
return modules_listed
async def req(event):
reqs = event.pattern_match.group(1).split()
message = f"Installing {len(reqs)} package(s):\n"
success = 0
for r in reqs:
message = message + f"{EMOJI_INSTALLING} {r}\n"
await event.edit(message)
try:
bout = subprocess.check_output(PIP_COMMAND.format(r).split())
output = bout.decode('ascii')
if f"Requirement already satisfied: {r}" in output:
message = message.replace(f"{EMOJI_INSTALLING} {r}",f"{EMOJI_FAILURE} {r} "\
"(package already installed)")
else:
message = message.replace(f"{EMOJI_INSTALLING} {r}",
f"{EMOJI_SUCCESS} {r}")
success = success + 1
except subprocess.CalledProcessError:
message = message.replace(f"{EMOJI_INSTALLING} {r}",
f"{EMOJI_FAILURE} {r}")
await event.edit(message.rstrip())
message = message.replace("Installing ", f"Installed {success}/")
if getConfig("LOGGING"):
await event_log(event, "REQUIREMENT INSTALLER", custom_text="{} of {} python "\
"packages queued were installed successfully!".format(success, len(reqs)))
await event.edit(message.rstrip())
return
def list_updater():
global MODULE_LIST
MODULE_LIST = []
assets = git.getAssets(git.getReleaseData(git.getData(UNIVERSE_URL), 0))
for asset in assets:
assetName = git.getReleaseFileName(asset)
assetURL = git.getReleaseFileURL(asset)
assetSize = git.getSize(asset)
MODULE_LIST.append({
"repo": UNIVERSE_NAME,
"name": assetName,
"url": assetURL,
"size": assetSize
})
for repoURL in getConfig("COMMUNITY_REPOS", []):
repoName = git.getReleaseTag(
git.getReleaseData(git.getData(repoURL), 0))
if repoName not in REPOS_NAMES:
REPOS_NAMES.append(repoName)
assets = git.getAssets(git.getReleaseData(git.getData(repoURL), 0))
for asset in assets:
assetName = git.getReleaseFileName(asset)
assetURL = git.getReleaseFileURL(asset)
assetSize = git.getSize(asset)
if assetName in MODULE_LIST:
MODULE_LIST.remove(MODULE_LIST["name"] == assetName)
MODULE_LIST.append({
"repo": repoName,
"name": assetName,
"url": assetURL,
"size": assetSize
})
return MODULE_LIST
async def event_log(event,
event_name: str,
user_name=None,
user_id=None,
username=None,
chat_title=None,
chat_link=None,
chat_id=None,
custom_text=None):
"""
Log any event by sending a message to the targeted chat
Args:
event (Event): any event e.g. NewMessage
event_name (str): name of event (not Telethon event) e.g. ban
user_name: name of user. Default to None
user_id: ID from user. Default to None
username: username from user. Default to None
chat_title: Title of the specific chat. Default to None
chat_link: link of the specific chat e.g. @example. Default to None
chat_id: link of the specific chat e.g. -100123456789. Default to None
custom_text: any custom text e.g. a note to the event. Default to None
Example:
@ehandler.on(command="example", outgoing=True)
async def example_handler(event):
user = fetch_user(event)
await event_log(event, "BAN", user_name=user.first_name, chat_id=event.chat_id)
"""
log_chat_id = getConfig("LOGGING_CHATID")
if not log_chat_id:
log.warning(
f"EVENT_LOG logging event '{event_name}' failed: LOGGING_CHATID is not set"
)
return
text = f"**{event_name}**\n"
if user_name and user_id and not username:
text += f"{msgsLang.LOG_USER}: [{user_name}](tg://user?id={user_id})\n"
elif user_name:
text += f"{msgsLang.LOG_USER}: {user_name}\n"
if username:
text += f"{msgsLang.LOG_USERNAME}: @{username}\n"
if user_id:
text += f"{msgsLang.LOG_USER_ID}: `{user_id}`\n"
if chat_title:
text += f"{msgsLang.LOG_CHAT_TITLE}: {chat_title}\n"
if chat_link:
text += f"{msgsLang.LOG_CHAT_LINK}: @{chat_link}\n"
if chat_id:
text += f"{msgsLang.LOG_CHAT_ID}: `{chat_id}`\n"
if custom_text:
text += f"{custom_text}"
try:
await event.client.send_message(log_chat_id, text)
except Exception as e:
log.warning(f"EVENT_LOG ({event_name}): {e}")
return
async def storage(event):
def list_dirs(source) -> list:
listed_dirs = []
for name in listdir(source):
srcname = join(source, name)
listed_dirs.append(srcname)
if isdir(srcname):
for elem in list_dirs(srcname):
listed_dirs.append(elem)
return listed_dirs
def getSizeFromPath(path) -> int:
listed_paths = list_dirs(path)
size = getsize(path)
for name in listed_paths:
size += getsize(name)
return size
ubot_size = getSizeFromPath(".")
sys_size = getSizeFromPath(join(".", "userbot", "modules"))
user_size = getSizeFromPath(join(".", "userbot", "modules_user"))
userdata_size = getSizeFromPath(getConfig("USERDATA"))
try:
tmpdl_size = getSizeFromPath(getConfig("TEMP_DL_DIR"))
except Exception:
tmpdl_size = 0
hdd = disk_usage("./")
result = f"**{msgRep.STORAGE}**\n\n"
result += f"__{msgRep.GENERAL}__\n"
result += f"`{msgRep.STORAGE_TOTAL}: {sizeStrMaker(hdd.total)}`\n"
result += f"`{msgRep.STORAGE_USED}: {sizeStrMaker(hdd.used)}`\n"
result += f"`{msgRep.STORAGE_FREE}: {sizeStrMaker(hdd.free)}`\n\n"
result += f"__{msgRep.USED_BY_HYPERUBOT}__\n"
result += f"`{msgRep.STORAGE_TOTAL}: {sizeStrMaker(ubot_size)}`\n"
result += f"`{msgRep.STORAGE_SYSTEM}: {sizeStrMaker(sys_size)}`\n"
result += f"`{msgRep.STORAGE_USER}: {sizeStrMaker(user_size)}`\n"
result += f"`{msgRep.STORAGE_USERDATA}: {sizeStrMaker(userdata_size)}`\n"
result += f"`{msgRep.STORAGE_TEMP_DL}: {sizeStrMaker(tmpdl_size)}`\n\n"
result += (f"`{msgRep.STORAGE_HDD} "
f"{textProgressBar(22, hdd.total, hdd.used)}`")
await event.edit(result)
return
def update_currency_data():
if exists(CC_CSV_PATH):
file_date = datetime.fromtimestamp(getmtime(CC_CSV_PATH))
duration = datetime.today() - file_date
if not duration.days >= 1: # don't update if file is not a day old
return
userdata_dir = getConfig("USERDATA")
if not userdata_dir:
log.warning("Userdata directory not available")
return
try:
zipfile = join(userdata_dir, "currency.zip")
# get latest data from the European Central Bank
z = urlopen("https://www.ecb.int/stats/eurofxref/eurofxref-hist.zip",
cafile=ca_where(),
capath=dirname(ca_where()))
with open(zipfile, "wb") as cur_zip:
cur_zip.write(z.read())
cur_zip.close()
except Exception as e:
log.warning(f"Unable to download updated data history: {e}")
return
try:
csv_filename = None
with ZipFile(zipfile, "r") as zipObject:
contents = zipObject.namelist()
for filename in contents:
if filename.endswith(".csv"):
csv_filename = filename
zipObject.extract(filename, userdata_dir)
break
zipObject.close()
try:
if exists(CC_CSV_PATH):
remove(CC_CSV_PATH)
except Exception as e:
log.warning(f"Unable to delete old csv file: {e}")
return
try:
rename(join(userdata_dir, csv_filename), CC_CSV_PATH)
log.info("[CURRENCY] data history successfully updated")
except Exception as e:
log.warning(f"Unable to rename csv file: {e}")
except BadZipFile as bze:
log.warning(f"Bad zip archive: {bze}")
except Exception as e:
log.warning(f"Failed to extract data history: {e}")
try:
remove(zipfile)
except Exception as e:
log.warning(f"Couldn't remove zip file: {e}")
return
async def restart(power_off): # Totally not a shutdown kang *sips whiskey*
cmd_args = power_off.pattern_match.group(1).split(" ", 1)
if cmd_args[0] == "safemode":
setConfig("REBOOT_SAFEMODE", True)
setConfig("REBOOT", True)
await power_off.edit(msgRep.RESTART)
time.sleep(1) # just so we can actually see a message
if getConfig("LOGGING"):
await event_log(power_off, "RESTART", custom_text=msgRep.RESTART_LOG)
await power_off.edit(msgRep.RESTARTED)
await power_off.client.disconnect()
async def kickme(leave):
if not isinstance(leave.message.peer_id, (PeerChannel, PeerChat)):
await leave.edit(msgRep.CANNOT_LEAVE)
return
await leave.edit(msgRep.LEAVING)
await leave.client.kick_participant(leave.chat_id, 'me')
if getConfig("LOGGING"):
await event_log(leave,
"KICKME",
chat_title=leave.chat.title,
chat_id=leave.chat_id)
return
async def restart(power_off): # Totally not a shutdown kang *sips whiskey*
if isWindows():
await power_off.edit(msgRep.RESTART_UNSUPPORTED)
return
cmd_args = power_off.pattern_match.group(1).split(" ", 1)
if cmd_args[0] == "safemode":
setConfig("REBOOT_SAFEMODE", True)
setConfig("REBOOT", True)
await power_off.edit(msgRep.RESTART)
if getConfig("LOGGING"):
await event_log(power_off, "RESTART", custom_text=msgRep.RESTART_LOG)
_setprop("reboot", True)
_setprop("rebootchatid", power_off.chat_id)
_setprop("rebootmsgid", power_off.message.id)
_setprop("rebootmsg", msgRep.RESTARTED)
await power_off.client.disconnect()
return
async def casSendAsFile(event, input_text: str):
await event.edit(msgRep.TOO_MANY_CAS)
try:
filename, success = createCASFile(
input_text, path.join(getConfig("TEMP_DL_DIR"), "caslist.txt"))
if success:
await event.client.send_file(event.chat_id, filename)
else:
await event.edit(msgRep.FAIL_UPLOAD_LIST)
except ChatSendMediaForbiddenError:
await event.edit(msgRep.SEND_MEDIA_FORBIDDEN)
except Exception as e:
log.warning(e)
await event.edit(msgRep.FAIL_UPLOAD_LIST)
if success:
remove(filename)
return
from googletrans import Translator, LANGUAGES
from gtts import gTTS
from gtts.tts import gTTSError
from logging import getLogger
from pydub import AudioSegment
from os import remove, rename
from os.path import exists, getmtime, join, dirname
from speech_recognition import (AudioFile, Recognizer, UnknownValueError,
RequestError)
from urllib.request import urlopen
from zipfile import BadZipFile, ZipFile
from certifi import where as ca_where
log = getLogger(__name__)
ehandler = EventHandler(log)
TEMP_DL_DIR = getConfig("TEMP_DL_DIR")
CC_CSV_PATH = join(getConfig("USERDATA"), "currency.csv")
DEST_LANG = getBotLangCode()
def build_supported_langs():
ret_val = ""
for i in LANGUAGES:
ret_val += "`{}`: {}\n".format(i, LANGUAGES[i])
return ret_val
@ehandler.on(command="scrlang", outgoing=True)
async def lang_check(event):
await event.edit(msgRep.SCRLANG.format(LANGUAGES[DEST_LANG]))
return
def __init__(self):
self.__imported_module = None
self.__load_modules_count = 0
self.__not_load_modules = getConfig("NOT_LOAD_MODULES", [])
len_before = len(environ.items())
load_dotenv(path.join(".", "userbot", "config.env"))
loaded_env = {
key: value
for key, value in list(environ.items())[len_before:]
}
if not SAFEMODE:
for key, value in loaded_env.items():
if not key in ("API_KEY", "API_HASH", "STRING_SESSION"):
if value.startswith("[") and value.endswith("]"):
addConfig(key, strlist_to_list(value))
elif value in ("True", "true", "False", "false"):
addConfig(key, str_to_bool(value))
else: # default case
addConfig(key, int(value) if value.isnumeric() else value)
if getConfig("SAMPLE_CONFIG", None):
log.error("Please remove SAMPLE_CONFIG from config.env!")
quit(1)
API_KEY = environ.get("API_KEY", None)
API_HASH = environ.get("API_HASH", None)
STRING_SESSION = environ.get("STRING_SESSION", None)
if SAFEMODE:
addConfig("UBOT_LANG", loaded_env.get("UBOT_LANG", "en"))
environ["API_KEY"] = "0"
environ["API_HASH"] = "None"
environ["STRING_SESSION"] = "None"
del loaded_env
elif path.exists(path.join(".", "userbot", "config.py")):
try:
import userbot.config
if not SAFEMODE:
ModuleUsages as usageRep)
from userbot.sysutils.configuration import getConfig
from userbot.sysutils.event_handler import EventHandler
from userbot.sysutils.registration import (register_cmd_usage,
register_module_desc,
register_module_info)
from userbot.version import VERSION
from telethon.errors import (ChatAdminRequiredError, InputUserDeactivatedError,
SearchQueryEmptyError)
from telethon.tl.functions.messages import SearchRequest
from telethon.tl.types import InputMessagesFilterEmpty, User
from logging import getLogger
log = getLogger(__name__)
ehandler = EventHandler(log)
LOGGING = getConfig("LOGGING")
@ehandler.on(command="msgs", hasArgs=True, outgoing=True)
async def countmessages(event):
user, chat = await fetch_user(event, get_chat=True)
if not user:
return
if not chat:
await event.edit(msgRep.FAIL_CHAT)
return
remote = isRemoteCMD(event, chat.id)
log.warning("No module(s) loaded!")
elif load_modules_count > 0:
log.info(f"Modules ({load_modules_count}/{sum_modules}) loaded and ready")
log.info("Starting Telegram client")
with tgclient:
me = tgclient.loop.run_until_complete(tgclient.get_me())
log.info("You're running %s v%s as %s (ID: %s)", PROJECT, VERSION, me.first_name, me.id)
tgclient.run_until_disconnected()
except KeyboardInterrupt:
log.info("Keyboard interruption. Exiting...")
except Exception as e:
log.critical(f"Unable to start HyperUBot: {e}", exc_info=True)
try:
# reboot reasons
perf_reboot = getConfig("REBOOT", False)
start_recovery = getConfig("START_RECOVERY", False)
if perf_reboot or start_recovery:
PY_EXEC = executable if not " " in executable else '"' + executable + '"'
if perf_reboot: # preferred if True
if getConfig("REBOOT_SAFEMODE"):
log.info("Rebooting into safe mode...")
tcmd = [PY_EXEC, "-m", "userbot", "-safemode"]
else:
log.info("Performing normal reboot...")
tcmd = [PY_EXEC, "-m", "userbot"]
elif start_recovery:
commit_id = getConfig("UPDATE_COMMIT_ID")
if commit_id:
log.info("Starting auto update in recovery...")
tcmd = [PY_EXEC, "recovery.py", "-autoupdate", commit_id]
async def shutdown(power_off):
await power_off.edit(msgRep.SHUTDOWN)
if getConfig("LOGGING"):
await event_log(power_off, "SHUTDOWN", custom_text=msgRep.SHUTDOWN_LOG)
await power_off.client.disconnect()
_moduleloader._unimport_module(module)
return
sys.modules[__name__] = _protectedAccess(
sys.modules[__name__],
attrs=[
"_tgclient",
"_moduleloader",
"_ModuleLoader",
"start_language_processor",
"import_module",
"unimport_module",
"update_all_modules",
"update_built_in_modules",
"update_load_modules",
"update_user_modules",
"update_handlers",
"unregister_module_desc",
"unregister_module_info",
"getHandlers",
"unregister_cmd",
],
allowed=((os.path.join("userbot", "modules", "_package_manager.py"),
os.path.join("userbot", "modules", "sideloader.py"))
if getConfig("SIDELOAD_NO_REBOOT", False) else os.path.join(
"userbot", "modules", "_package_manager.py")),
warn_msg=("Unauthorized access to protected attribute blocked "
"(requested by {1}:{2})"),
mlogger=log)
from os.path import basename
from os.path import join as pathjoin
import os
from userbot.config import PlusConfig as pc
from userbot.sysutils.registration import register_cmd_usage, register_module_desc, register_module_info
from userbot.sysutils.event_handler import EventHandler
from userbot.sysutils.configuration import getConfig
from userbot import getConfig
from telethon.tl.functions.channels import EditBannedRequest
from telethon.tl.types import ChatBannedRights
from datetime import datetime, timedelta
from telethon.errors import UserAdminInvalidError
ehandler = EventHandler()
VERSION = "2022.1.2"
TEMP_DL_DIR = getConfig("TEMP_DL_DIR")
if getConfig("USERDATA") == None:
raise Exception("disease requires a user data folder. Please set USERDATA in your config.")
FILES = pathjoin(getConfig("USERDATA"),"plus")
if not os.path.isdir(FILES):
os.makedirs(FILES)
def progress(current, total):
print("Downloaded {} of {}\nCompleted {}".format(current, total, (current / total) * 100))
@ehandler.on(command="infect", hasArgs=True, outgoing=True)
async def infect(event):
if not event.text[0].isalpha() and event.text[0] in ("."):
_len_before = len(environ.items())
load_dotenv(path.join(".", "userbot", "config.env"))
loaded_env = {
key: value
for key, value in list(environ.items())[_len_before:]
}
if not SAFEMODE:
for key, value in loaded_env.items():
if key not in ("API_KEY", "API_HASH", "STRING_SESSION"):
if value.startswith("[") and value.endswith("]"):
addConfig(key, strlist_to_list(value))
elif value in ("True", "true", "False", "false"):
addConfig(key, str_to_bool(value))
else: # default case
addConfig(key, int(value) if value.isnumeric() else value)
if getConfig("SAMPLE_CONFIG", None):
log.error("Please remove SAMPLE_CONFIG from config.env!")
quit(1)
if SAFEMODE:
addConfig("UBOT_LANG", loaded_env.get("UBOT_LANG", "en"))
environ["API_KEY"] = "0"
environ["API_HASH"] = "None"
environ["STRING_SESSION"] = "None"
del loaded_env
elif path.exists(path.join(".", "userbot", "config.py")):
_cfg_loadable = False
try:
import userbot.config as cfg
_cfg_loadable = True
except (IndentationError, NameError, TypeError, ValueError,
SyntaxError): # totally F
return
await event.client.download_media(message=msg, file=dest_path)
log.info(f"Module '{file.name[:-3]}' has been installed to userpace")
await event.edit(msgRep.SUCCESS.format(file.name))
if getConfig("LOGGING"):
await event_log(event,
"SIDELOAD",
custom_text=msgRep.LOG.format(file.name))
log.info("Rebooting userbot...")
time.sleep(1)
await event.edit(msgRep.RBT_CPLT)
setConfig("REBOOT", True)
await event.client.disconnect()
else:
await event.edit(msgRep.INVALID_FILE)
return
if getConfig("ALLOW_SIDELOAD"):
register_cmd_usage(
"sideload",
usageRep.SIDELOADER_USAGE.get("sideload", {}).get("args"),
usageRep.SIDELOADER_USAGE.get("sideload", {}).get("usage"))
else:
register_cmd_usage("sideload", None, None)
register_module_desc(descRep.SIDELOADER_DESC)
register_module_info(name="Sideloader",
authors="nunopenim, prototype74",
version=VERSION)
def __init__(self):
"""
Initialize the module loader
"""
self.__not_load_modules = getConfig("NOT_LOAD_MODULES", [])
async def speedtest(event):
arg_from_event = event.pattern_match.group(1)
chat = await event.get_chat()
share_as_pic = True if arg_from_event.lower() == "pic" else False
if share_as_pic:
# if speedtest is send to a group and send media is not allowed then skip 'pic' argument
if hasattr(chat, "default_banned_rights") and not chat.creator and not chat.admin_rights and \
chat.default_banned_rights.send_media:
share_as_pic = False # disable
process = None
all_test_passed = False
check_mark = u"\u2705"
warning = u"\u26A0"
try:
process = f"**Speedtest by Ookla**\n\n- {msgRep.SPD_TEST_SELECT_SERVER}..."
await event.edit(process)
s = Speedtest()
s.get_best_server()
process = f"**Speedtest by Ookla**\n\n- {msgRep.SPD_TEST_SELECT_SERVER} {check_mark}\n" \
f"- {msgRep.SPD_TEST_DOWNLOAD}..."
await event.edit(process)
s.download()
process = f"**Speedtest by Ookla**\n\n- {msgRep.SPD_TEST_SELECT_SERVER} {check_mark}\n" \
f"- {msgRep.SPD_TEST_DOWNLOAD} {check_mark}\n- {msgRep.SPD_TEST_UPLOAD}..."
await event.edit(process)
s.upload()
process = f"**Speedtest by Ookla**\n\n- {msgRep.SPD_TEST_SELECT_SERVER} {check_mark}\n" \
f"- {msgRep.SPD_TEST_DOWNLOAD} {check_mark}\n- {msgRep.SPD_TEST_UPLOAD} {check_mark}"
all_test_passed = True
if share_as_pic:
s.results.share()
result = s.results.dict()
if not result:
await event.edit(process + "\n\n" +
f"`{msgRep.SPD_FAILED}: {msgRep.SPD_NO_RESULT}`")
return
except MemoryError as me:
log.error(me)
if not all_test_passed:
process = process[:-3] + f" {warning}"
await event.edit(process + "\n\n" +
f"`{msgRep.SPD_FAILED}: {msgRep.SPD_NO_MEMORY}`")
else:
await event.edit(process + "\n\n" +
f"`{msgRep.SPD_FAILED}: {msgRep.SPD_NO_MEMORY}`")
return
except Exception as e:
log.error(e)
if not all_test_passed:
process = process[:-3] + f" {warning}"
await event.edit(process + "\n\n" + msgRep.SPD_FAILED)
else:
await event.edit(process + "\n\n" + msgRep.SPD_FAILED)
return
if share_as_pic:
try:
await event.edit(process + "\n\n" + f"{msgRep.SPD_PROCESSING}...")
png_file = getConfig("TEMP_DL_DIR") + "speedtest.png"
urlretrieve(result["share"], png_file)
await event.client.send_file(chat.id, png_file)
await event.delete()
remove(png_file)
except Exception as e:
log.error(e)
await event.edit(msgRep.SPD_FAIL_SEND_RESULT)
else:
# Convert speed to Mbit/s
down_in_mbits = round(result["download"] / 10**6, 2)
up_in_mbits = round(result["upload"] / 10**6, 2)
# Convert speed to MB/s (real speed?)
down_in_mb = round(result["download"] / ((10**6) * 8), 2)
up_in_mb = round(result["upload"] / ((10**6) * 8), 2)
time = parse(result["timestamp"])
ping = result["ping"]
isp = result["client"]["isp"]
host = result["server"]["sponsor"]
host_cc = result["server"]["cc"]
text = "<b>Speedtest by Ookla</b>\n\n"
text += f"<b>{msgRep.SPD_TIME}</b>: <code>{time.strftime('%B %d, %Y')} - {time.strftime('%H:%M:%S')} {time.tzname()}</code>\n"
text += f"<b>{msgRep.SPD_DOWNLOAD}</b>: <code>{down_in_mbits}</code> {msgRep.SPD_MEGABITS} (<code>{down_in_mb}</code> {msgRep.SPD_MEGABYTES})\n"
text += f"<b>{msgRep.SPD_UPLOAD}</b>: <code>{up_in_mbits}</code> {msgRep.SPD_MEGABITS} (<code>{up_in_mb}</code> {msgRep.SPD_MEGABYTES})\n"
text += f"<b>{msgRep.SPD_PING}</b>: <code>{ping}</code> ms\n"
text += f"<b>{msgRep.SPD_ISP}</b>: {isp}\n"
text += f"<b>{msgRep.SPD_HOSTED_BY}</b>: {host} ({host_cc})\n"
await event.edit(text, parse_mode="html")
return
def modules_listing(error_text: str = None) -> str:
modules_listed = f"**{msgRep.MOD_UTILS}**\n\n"
if error_text:
modules_listed += f"{error_text}\n"
if _attempts >= 2:
modules_listed += f"{msgRep.MOD_HELP.format('`.help mods`')}\n"
modules_listed += "\n"
sys_count, user_count = installed_modules()
modules_listed += f"`{msgRep.SYSTEM_MODULES}: {sys_count}`\n"
modules_listed += (f"`{msgRep.USER_MODULES}: {user_count}`\n\n"
if not SAFEMODE else "\n")
check_mark = u"\u2705"
modules_listed += f"{check_mark} {msgRep.AVAILABLE_MODULES}:\n"
modules_list = update_list()
all_running = all(True if ir else False
for ir in [modules[-1] for modules in modules_list])
num = 0
warning = u"\u26A0" # warn emoji
recycle = u"\u267B" # recycling emoji
user_modules = getUserModules()
for module_name, module, isRunning in modules_list:
num += 1
if module in user_modules:
if isRunning:
modules_listed += (f"`({str(num)}) {module_name}` {recycle}\n")
else:
modules_listed += (f"`({str(num)}) {module_name}` {recycle} "
f"{warning}\n")
else:
if isRunning:
modules_listed += (f"`({str(num)}) {module_name}`\n")
else:
modules_listed += (f"`({str(num)}) {module_name}` {warning}\n")
not_load_modules = getConfig("NOT_LOAD_MODULES", [])
if not_load_modules:
all_modules = getAllModules()
if any(module for module in not_load_modules if module in all_modules):
modules_listed += "\n"
no_entry = u"\u26D4"
modules_listed += f"{no_entry} {msgRep.DISABLED_MODULES}:\n"
for module in sorted(not_load_modules):
if module in all_modules:
if module in user_modules:
modules_listed += f"`- {module}` {recycle}\n"
else:
modules_listed += f"`- {module}`\n"
modules_listed += "\n"
if user_modules and not SAFEMODE:
modules_listed += f"{recycle} __{msgRep.ASTERISK}__\n"
if not all_running:
modules_listed += f"{warning} __{msgRep.NOT_RUNNING_INFO}__\n"
return modules_listed
async def updater(upd):
global RAN
global FOUND_UPD
args = upd.pattern_match.group(1)
if args.lower() == "upgrade":
if not RAN:
await upd.edit(msgRep.UPDATES_NOT_RAN)
return
if not FOUND_UPD:
await upd.edit(msgRep.NO_UPDATES)
return
try:
await upd.edit(msgRep.UPDATING)
gitpull = check_output("git pull", shell=True).decode()
log.info(gitpull)
pip = check_output(EXECUTABLE +
" -m pip install -r requirements.txt",
shell=True).decode()
log.info(pip)
except CalledProcessError:
await upd.edit(msgRep.UPD_ERROR)
return
await upd.edit(msgRep.UPD_SUCCESS)
time.sleep(1)
if getConfig("LOGGING"):
await event_log(upd, "UPDATE", custom_text=msgRep.UPD_LOG)
await upd.edit(msgRep.RBT_COMPLETE)
args = [EXECUTABLE, "-m", "userbot"]
os.execle(sys.executable, *args, os.environ)
await upd.client.disconnect()
return
else:
repo = Repo()
branch = repo.active_branch.name
if not (branch in ['master', 'staging']):
await upd.edit(msgRep.UNKWN_BRANCH)
return
try:
repo.create_remote('upstream', BOT_REPO_URL)
except BaseException:
pass
repo.remote('upstream').fetch(branch)
changelog = ''
counter = 1
for commit in repo.iter_commits("HEAD..upstream/" + branch):
changelog += "{}. [{}] > `{}`\n".format(counter, commit.author,
commit.summary)
counter += 1
if not changelog:
await upd.edit(msgRep.LATS_VERSION.format(PROJECT))
RAN = True
return
if changelog:
try:
retText = msgRep.UPD_AVAIL
retText += changelog
retText += msgRep.RUN_UPD
await upd.edit(retText)
except MessageTooLongError:
retText = msgRep.CHLG_TOO_LONG
await upd.edit(retText)
RAN = True
FOUND_UPD = True
return
from userbot.include.aux_funcs import module_info
from userbot.include.language_processor import CasIntText as msgRep, ModuleDescriptions as descRep, ModuleUsages as usageRep
from userbot.sysutils.configuration import getConfig
from userbot.sysutils.event_handler import EventHandler
from telethon.errors import ChatAdminRequiredError, MessageTooLongError, ChatSendMediaForbiddenError
from telethon.tl.types import User, Chat, Channel, PeerUser, PeerChannel
from datetime import datetime
from logging import getLogger
from os import remove
from os.path import basename, exists, getmtime
from requests import get, ConnectionError, Timeout
from time import sleep
log = getLogger(__name__)
ehandler = EventHandler(log)
CAS_CSV = getConfig("TEMP_DL_DIR") + "export.csv"
CAS_USER_IDS = []
def updateCASList() -> bool:
global CAS_USER_IDS
try:
if CAS_USER_IDS:
CAS_USER_IDS = [] # reset before appending again
with open(CAS_CSV, "r") as data:
for cas_id in data:
try:
CAS_USER_IDS.append(int(cas_id))
except:
pass
data.close()
from currency_converter import CurrencyConverter
from googletrans import Translator, LANGUAGES
from gtts import gTTS
from gtts.tts import gTTSError
from logging import getLogger
from pydub import AudioSegment
from os import remove, rename
from os.path import exists, getmtime, join
from speech_recognition import (AudioFile, Recognizer, UnknownValueError,
RequestError)
from urllib.request import urlretrieve
from zipfile import BadZipFile, ZipFile
log = getLogger(__name__)
ehandler = EventHandler(log)
TEMP_DL_DIR = getConfig("TEMP_DL_DIR")
CC_CSV_PATH = join(TEMP_DL_DIR, "currency.csv")
DEST_LANG = getBotLangCode()
def build_supported_langs():
ret_val = ""
for i in LANGUAGES.keys():
ret_val += "`{}`: {}\n".format(i, LANGUAGES[i])
return ret_val
@ehandler.on(command="scrlang", outgoing=True)
async def lang_check(event):
await event.edit(msgRep.SCRLANG.format(LANGUAGES[DEST_LANG]))
return
