def slap(bot: Bot, update: Update, args: List[str]):
chat = update.effective_chat
msg = update.effective_message
# reply to correct message
reply_text = msg.reply_to_message.reply_text if msg.reply_to_message else msg.reply_text
# get user who sent message
if msg.from_user.username:
curr_user = "******" + escape_markdown(msg.from_user.username)
else:
curr_user = "******".format(msg.from_user.first_name,
msg.from_user.id)
user_id = extract_user(update.effective_message, args)
if user_id:
slapped_user = bot.get_chat(user_id)
user1 = curr_user
if slapped_user.username == "RealAkito":
reply_text(tld(chat.id, "memes_not_doing_that"))
return
if slapped_user.username:
user2 = "@" + escape_markdown(slapped_user.username)
else:
user2 = "[{}](tg://user?id={})".format(slapped_user.first_name,
slapped_user.id)
# if no target found, bot targets the sender
else:
user1 = "[{}](tg://user?id={})".format(bot.first_name, bot.id)
user2 = curr_user
temp = random.choice(tld_list(chat.id, "memes_slaps_templates_list"))
item = random.choice(tld_list(chat.id, "memes_items_list"))
hit = random.choice(tld_list(chat.id, "memes_hit_list"))
throw = random.choice(tld_list(chat.id, "memes_throw_list"))
itemp = random.choice(tld_list(chat.id, "memes_items_list"))
itemr = random.choice(tld_list(chat.id, "memes_items_list"))
repl = temp.format(user1=user1,
user2=user2,
item=item,
hits=hit,
throws=throw,
itemp=itemp,
itemr=itemr)
reply_text(repl, parse_mode=ParseMode.MARKDOWN)
def check_and_ban(update, user_id, should_message=True):
chat = update.effective_chat
message = update.effective_message
try:
if sw is not None:
if sw_ban := sw.get_ban(user_id):
spamwatch_reason = sw_ban.reason
chat.kick_member(user_id)
if should_message:
message.reply_text(tld(
chat.id,
"antispam_spamwatch_banned").format(spamwatch_reason),
parse_mode=ParseMode.HTML)
return
except Exception:
pass
def get_rules(bot: Bot, update: Update):
chat = update.effective_chat
user = update.effective_user
from_pm = False
conn = connected(bot, update, chat, user.id)
if conn:
chat_id = conn
from_pm = True
else:
if chat.type == 'private':
msg.reply_text(tld(chat.id, 'common_cmd_group_only'))
return
chat_id = chat.id
send_rules(update, chat_id, from_pm)
def afk(bot: Bot, update: Update):
chat = update.effective_chat
user = update.effective_user
if not user: # ignore channels
return
if user.id in (777000, 1087968824):
return
args = update.effective_message.text.split(None, 1)
reason = args[1] if len(args) >= 2 else ""
sql.set_afk(update.effective_user.id, reason)
fname = update.effective_user.first_name
update.effective_message.reply_text(
tld(chat.id, "user_now_afk").format(fname))
def build_lock_message(chat, chatP, user, chatname):
locks = sql.get_locks(chat.id)
restr = sql.get_restr(chat.id)
if not locks:
sql.init_permissions(chat.id)
locks = sql.get_locks(chat.id)
if not restr:
sql.init_restrictions(chat.id)
restr = sql.get_restr(chat.id)
return tld(chatP.id, "locks_list").format(
chatname, locks.sticker, locks.audio, locks.voice, locks.document,
locks.video, locks.videonote, locks.contact, locks.photo, locks.gif,
locks.url, locks.bots, locks.forward, locks.game, locks.location,
restr.messages, restr.media, restr.other, restr.preview,
all([restr.messages, restr.media, restr.other, restr.preview]))
async def phh(c: Client, update: Update):
chat_id = update.chat.id
fetch = get(
"https://api.github.com/repos/phhusson/treble_experimentations/releases/latest"
)
usr = json.loads(fetch.content)
reply_text = tld(chat_id, "phh_releases")
for i in range(len(usr)):
try:
name = usr['assets'][i]['name']
url = usr['assets'][i]['browser_download_url']
reply_text += f"[{name}]({url})\n"
except IndexError:
continue
await update.reply_text(reply_text)
def warn_user(bot: Bot, update: Update, args: List[str]) -> str:
message = update.effective_message
chat = update.effective_chat
warner = update.effective_user
user_id, reason = extract_user_and_text(message, args)
if user_id:
if message.reply_to_message and message.reply_to_message.from_user.id == user_id:
return warn(message.reply_to_message.from_user, chat, reason,
message.reply_to_message, warner)
else:
return warn(
chat.get_member(user_id).user, chat, reason, message, warner)
else:
message.reply_text(tld(chat.id, 'common_err_no_user'))
return ""
async def anime_airing(c: Client, m: Message):
search_str = m.text.split(' ', 1)
chat_id = m.chat.id
if len(search_str) == 1:
await m.reply_text(tld(chat_id, "anime_no_arg"))
return
variables = {'search': search_str[1]}
response = requests.post(
url, json={'query': airing_query, 'variables': variables}).json()['data']['Media']
ms_g = f"**Name**: **{response['title']['romaji']}**(`{response['title']['native']}`)\n**ID**: `{response['id']}`"
if response['nextAiringEpisode']:
airing_time = response['nextAiringEpisode']['timeUntilAiring'] * 1000
airing_time_final = t(airing_time)
ms_g += f"\n**Episode**: `{response['nextAiringEpisode']['episode']}`\n**Airing In**: `{airing_time_final}`"
else:
ms_g += f"\n**Episode**:{response['episodes']}\n**Status**: `N/A`"
await m.reply_text(ms_g)
def no_longer_afk(bot: Bot, update: Update):
user = update.effective_user
chat = update.effective_chat
message = update.effective_message
if not user: # ignore channels
return
res = sql.rm_afk(user.id)
if res:
if message.new_chat_members: # dont say msg
return
firstname = update.effective_user.first_name
try:
message.reply_text(
tld(chat.id, "user_no_longer_afk").format(firstname))
except Exception:
return
def is_admin(bot: Bot, update: Update, *args, **kwargs):
user = update.effective_user
chat = update.effective_chat
if user and is_user_admin(update.effective_chat, user.id):
try:
return func(bot, update, *args, **kwargs)
except Exception:
return
elif not user:
pass
elif DEL_CMDS and " " not in update.effective_message.text:
update.effective_message.delete()
elif (admin_sql.command_reaction(chat.id) is True):
update.effective_message.reply_text(
tld(chat.id, 'helpers_user_not_admin'))
def unpin(bot: Bot, update: Update) -> str:
chat = update.effective_chat
user = update.effective_user
message = update.effective_message
if user_can_pin(chat, user, bot.id) is False:
message.reply_text(tld(chat.id, "admin_no_pin_perm"))
return ""
try:
bot.unpinChatMessage(chat.id)
except BadRequest as excp:
if excp.message != "Chat_not_modified":
raise
return f"<b>{html.escape(chat.title)}:</b>" \
"\n#UNPINNED" \
f"\n<b>• Admin:</b> {mention_html(user.id, user.first_name)}"
def zalgotext(bot: Bot, update: Update, args: List[str]):
message = update.effective_message
chat = update.effective_chat
noreply = False
if message.reply_to_message:
data = message.reply_to_message.text
elif args:
noreply = True
data = message.text.split(None, 1)[1]
else:
noreply = True
data = tld(chat.id, "memes_no_message")
reply_text = zalgo.zalgo().zalgofy(data)
if noreply:
message.reply_text(reply_text)
else:
message.reply_to_message.reply_text(reply_text)
async def phh(event):
if event.from_id is None:
return
chat_id = event.chat_id
fetch = get(
"https://api.github.com/repos/phhusson/treble_experimentations/releases/latest"
)
usr = json.loads(fetch.content)
reply_text = tld(chat_id, "phh_releases")
for i in range(len(usr)):
try:
name = usr['assets'][i]['name']
url = usr['assets'][i]['browser_download_url']
reply_text += f"[{name}]({url})\n"
except IndexError:
continue
await event.reply(reply_text)
async def pixys(c: Client, update: Update):
chat_id = update.chat.id,
try:
device = update.command[1]
except Exception:
device = ''
if device == '':
reply_text = tld(chat_id, "cmd_example").format("pixys")
await update.reply_text(reply_text, disable_web_page_preview=True)
return
fetch = get(
f'https://raw.githubusercontent.com/PixysOS-Devices/official_devices/ten/{device}/build.json'
)
if fetch.status_code == 200:
usr = fetch.json()
response = usr['response'][0]
filename = response['filename']
url = response['url']
buildsize_a = response['size']
buildsize_b = sizee(int(buildsize_a))
romtype = response['romtype']
version = response['version']
reply_text = tld(chat_id, "download").format(filename, url)
reply_text += tld(chat_id, "build_size").format(buildsize_b)
reply_text += tld(chat_id, "version").format(version)
reply_text += tld(chat_id, "rom_type").format(romtype)
keyboard = [[
InlineKeyboardButton(text=tld(chat_id, "btn_dl"), url=f"{url}")
]]
await update.reply_text(reply_text,
reply_markup=InlineKeyboardMarkup(keyboard),
parse_mode="markdown",
disable_web_page_preview=True)
return
elif fetch.status_code == 404:
reply_text = tld(chat_id, "err_not_found")
await update.reply_text(reply_text,
parse_mode="markdown",
disable_web_page_preview=True)
def set_flood(bot: Bot, update: Update, args: List[str]) -> str:
chat = update.effective_chat
user = update.effective_user
message = update.effective_message
if user_can_changeinfo(chat, user, bot.id) is False:
message.reply_text(tld(chat.id, "admin_no_changeinfo_perm"))
return ""
if len(args) >= 1:
val = args[0].lower()
if val in ("off", "no", "0"):
sql.set_flood(chat.id, 0)
message.reply_text(tld(chat.id, "flood_set_off"))
elif val.isdigit():
amount = int(val)
if amount <= 0:
sql.set_flood(chat.id, 0)
message.reply_text(tld(chat.id, "flood_set_off"))
return tld(chat.id, "flood_logger_set_off").format(
html.escape(chat.title),
mention_html(user.id, user.first_name))
elif amount < 3:
message.reply_text(tld(chat.id, "flood_err_num"))
return ""
else:
sql.set_flood(chat.id, amount)
message.reply_text(tld(chat.id, "flood_set").format(amount))
return tld(chat.id, "flood_logger_set_on").format(
html.escape(chat.title),
mention_html(user.id, user.first_name), amount)
else:
message.reply_text(tld(chat.id, "flood_err_args"))
return ""
def vapor(bot: Bot, update: Update, args: List[str]):
message = update.effective_message
chat = update.effective_chat
noreply = False
if message.reply_to_message:
data = message.reply_to_message.text
elif args:
noreply = True
data = message.text.split(None, 1)[1]
else:
noreply = True
data = tld(chat.id, "memes_no_message")
reply_text = str(data).translate(WIDE_MAP)
if noreply:
message.reply_text(reply_text)
else:
message.reply_to_message.reply_text(reply_text)
async def character_search(c: Client, m: Message):
search = m.text.split(' ', 1)
chat_id = m.chat.id
if len(search) == 1:
await m.reply_text(tld(chat_id, "character_no_arg"))
return
search = search[1]
variables = {'query': search}
if (json := requests.post(url,
json={
'query': character_query,
'variables': variables
}).json()['data'].get('Character', None)):
ms_g = f"**{json.get('name').get('full')}**(`{json.get('name').get('native')}`)\n"
description = f"{json['description']}"
site_url = json.get('siteUrl')
ms_g += shorten(description, site_url)
if image := json.get('image', None):
image = image.get('large')
await m.reply_photo(image, caption=ms_g)
def shout(bot: Bot, update: Update, args: List[str]):
message = update.effective_message
chat = update.effective_chat
if message.reply_to_message:
data = message.reply_to_message.text
elif args:
data = " ".join(args)
else:
data = tld(chat.id, "memes_no_message")
msg = "```"
result = [' '.join(list(data))]
for pos, symbol in enumerate(data[1:]):
result.append(symbol + ' ' + ' ' * pos + symbol)
result = list("\n".join(result))
result[0] = data[0]
result = "".join(result)
msg = "```\n" + result + "```"
return update.effective_message.reply_text(msg, parse_mode="MARKDOWN")
def log_action(bot: Bot, update: Update, *args, **kwargs):
try:
result = func(bot, update, *args, **kwargs)
except Exception:
return
chat = update.effective_chat # type: Optional[Chat]
message = update.effective_message # type: Optional[Message]
if result:
if chat.type == chat.SUPERGROUP and chat.username:
result += tld(chat.id, "log_channel_link").format(
chat.username, message.message_id)
log_chat = sql.get_chat_log_channel(chat.id)
if log_chat:
send_log(bot, log_chat, chat.id, result)
elif result == "":
pass
else:
LOGGER.warning(
"%s was set as loggable, but had no return statement.", func)
return result
def stretch(bot: Bot, update: Update, args: List[str]):
chat = update.effective_chat
message = update.effective_message
noreply = False
if message.reply_to_message:
data = message.reply_to_message.text
elif args:
noreply = True
data = message.text.split(None, 1)[1]
else:
noreply = True
data = tld(chat.id, "memes_no_message")
count = random.randint(3, 10)
reply_text = re.sub(r'([aeiouAEIOUａｅｉｏｕＡＥＩＯＵ])', (r'\1' * count), data)
if noreply:
message.reply_text(reply_text)
else:
message.reply_to_message.reply_text(reply_text)
def locale(bot, update, args):
chat = update.effective_chat
message = update.effective_message
if len(args) > 0:
locale = args[0].lower()
if locale == 'en-us':
locale = 'en-US'
if locale in ['en-uk', 'en-gb']:
locale = 'en-GB'
if locale in list_locales:
if locale in LANGUAGES:
switch_to_locale(chat.id, locale)
if chat.type == "private":
message.reply_text(
tld(chat.id, 'language_switch_success_pm').format(
list_locales[locale]))
else:
message.reply_text(
tld(chat.id, 'language_switch_success').format(
chat.title, list_locales[locale]))
else:
text = tld(chat.id, "language_not_supported").format(
list_locales[locale])
text += "\n\n*Currently available languages:*\n"
for lang in LANGUAGES:
locale = list_locales[lang]
text += "\n *{}* - `{}`".format(locale, lang)
message.reply_text(text, parse_mode=ParseMode.MARKDOWN)
else:
text = tld(chat.id, "language_code_not_valid")
text += "\n\n*Currently available languages:*\n"
for lang in LANGUAGES:
locale = list_locales[lang]
text += "\n *{}* - `{}`".format(locale, lang)
message.reply_text(text, parse_mode=ParseMode.MARKDOWN)
else:
LANGUAGE = prev_locale(chat.id)
if LANGUAGE:
locale = LANGUAGE.locale_name
native_lang = list_locales[locale]
message.reply_text(tld(
chat.id, "language_current_locale").format(native_lang),
parse_mode=ParseMode.MARKDOWN)
else:
message.reply_text(tld(
chat.id, "language_current_locale").format("English (US)"),
parse_mode=ParseMode.MARKDOWN)
def help_button(bot: Bot, update: Update):
query = update.callback_query
chat = update.effective_chat
back_match = re.match(r"help_back", query.data)
mod_match = re.match(r"help_module\((.+?)\)", query.data)
try:
if mod_match:
module = mod_match.group(1)
mod_name = tld(chat.id, "modname_" + module).strip()
help_txt = tld(
chat.id, module +
"_help") # tld_help(chat.id, HELPABLE[module].__mod_name__)
if not help_txt:
LOGGER.exception(f"Help string for {module} not found!")
text = tld(chat.id, "here_is_help").format(mod_name, help_txt)
bot.edit_message_text(chat_id=query.message.chat_id,
message_id=query.message.message_id,
text=text,
parse_mode=ParseMode.MARKDOWN,
reply_markup=InlineKeyboardMarkup([[
InlineKeyboardButton(
text=tld(chat.id, "btn_go_back"),
callback_data="help_back")
]]),
disable_web_page_preview=True)
elif back_match:
bot.edit_message_text(chat_id=query.message.chat_id,
message_id=query.message.message_id,
text=tld(chat.id, "send-help").format(
dispatcher.bot.first_name,
tld(chat.id, "cmd_multitrigger")),
parse_mode=ParseMode.MARKDOWN,
reply_markup=InlineKeyboardMarkup(
paginate_modules(chat.id, 0, HELPABLE,
"help")),
disable_web_page_preview=True)
# ensure no spinny white circle
bot.answer_callback_query(query.id)
# query.message.delete()
except BadRequest:
pass
def user_join_fed(bot: Bot, update: Update, args: List[str]):
chat = update.effective_chat
user = update.effective_user
msg = update.effective_message
fed_id = sql.get_fed_id(chat.id)
if is_user_fed_owner(fed_id, user.id):
user_id = extract_user(msg, args)
if user_id:
user = bot.get_chat(user_id)
elif not msg.reply_to_message and not args:
user = msg.from_user
elif not msg.reply_to_message and (
not args or
(len(args) >= 1 and not args[0].startswith("@")
and not args[0].isdigit()
and not msg.parse_entities([MessageEntity.TEXT_MENTION]))):
msg.reply_text(tld(chat.id, "common_err_no_user"))
return
else:
LOGGER.warning('error')
getuser = sql.search_user_in_fed(fed_id, user_id)
fed_id = sql.get_fed_id(chat.id)
info = sql.get_fed_info(fed_id)
get_owner = eval(info['fusers'])['owner']
get_owner = bot.get_chat(get_owner).id
if user_id == get_owner:
update.effective_message.reply_text(
tld(chat.id, "feds_promote_owner"))
return
if getuser:
update.effective_message.reply_text(
tld(chat.id, "feds_promote_owner"))
return
if user_id == bot.id:
update.effective_message.reply_text(
tld(chat.id, "feds_promote_bot"))
return
res = sql.user_join_fed(fed_id, user_id)
if res:
update.effective_message.reply_text(
tld(chat.id, "feds_promote_success"))
else:
update.effective_message.reply_text("")
else:
update.effective_message.reply_text(tld(chat.id, "feds_owner_only"))
def owo(bot: Bot, update: Update, args: List[str]):
chat = update.effective_chat
message = update.effective_message
noreply = False
if message.reply_to_message:
data = message.reply_to_message.text
elif args:
noreply = True
data = message.text.split(None, 1)[1]
else:
noreply = True
data = tld(chat.id, "memes_no_message")
faces = [
'(・`ω´・)', ';;w;;', 'owo', 'UwU', '>w<', '^w^', '\(^o\) (/o^)/',
'( ^ _ ^)∠☆', '(ô_ô)', '~:o', ';____;', '(*^*)', '(>_', '(♥_♥)',
'*(^O^)*', '((+_+))'
]
reply_text = re.sub(r'[rl]', "w", data)
reply_text = re.sub(r'[ｒｌ]', "ｗ", data)
reply_text = re.sub(r'[RL]', 'W', reply_text)
reply_text = re.sub(r'[ＲＬ]', 'Ｗ', reply_text)
reply_text = re.sub(r'n([aeiouａｅｉｏｕ])', r'ny\1', reply_text)
reply_text = re.sub(r'ｎ([ａｅｉｏｕ])', r'ｎｙ\1', reply_text)
reply_text = re.sub(r'N([aeiouAEIOU])', r'Ny\1', reply_text)
reply_text = re.sub(r'Ｎ([ａｅｉｏｕＡＥＩＯＵ])', r'Ｎｙ\1', reply_text)
reply_text = re.sub(r'\!+', ' ' + random.choice(faces), reply_text)
reply_text = re.sub(r'！+', ' ' + random.choice(faces), reply_text)
reply_text = reply_text.replace("ove", "uv")
reply_text = reply_text.replace("ｏｖｅ", "ｕｖ")
reply_text += ' ' + random.choice(faces)
if noreply:
message.reply_text(reply_text)
else:
message.reply_to_message.reply_text(reply_text)
def rm_blacklist_url(bot: Bot, update: Update):
chat = update.effective_chat
message = update.effective_message
urls = message.text.split(None, 1)
if len(urls) > 1:
urls = urls[1]
to_unblacklist = list(
{uri.strip() for uri in urls.split("\n") if uri.strip()})
unblacklisted = 0
for uri in to_unblacklist:
extract_url = tldextract.extract(uri)
success = sql.rm_url_from_blacklist(
chat.id, f'{extract_url.domain}.{extract_url.suffix}'
)
if success:
unblacklisted += 1
if len(to_unblacklist) == 1:
if unblacklisted:
message.reply_text(tld(chat.id,
"url_blacklist_remove_success").format(
html.escape(to_unblacklist[0])),
parse_mode=ParseMode.HTML)
else:
message.reply_text(tld(chat.id,
"url_blacklist_remove_invalid"))
elif unblacklisted == len(to_unblacklist):
message.reply_text(
tld(chat.id,
"url_blacklist_remove_success_2").format(unblacklisted),
parse_mode=ParseMode.HTML)
elif not unblacklisted:
message.reply_text(tld(chat.id, "url_blacklist_remove_invalid_2"),
parse_mode=ParseMode.HTML)
else:
message.reply_text(tld(chat.id,
"url_blacklist_remove_success_3").format(
unblacklisted,
len(to_unblacklist) - unblacklisted),
parse_mode=ParseMode.HTML)
else:
message.reply_text(tld(chat.id, "url_blacklist_remove_invalid_3"))
def user_demote_fed(bot: Bot, update: Update, args: List[str]):
chat = update.effective_chat
user = update.effective_user
fed_id = sql.get_fed_id(chat.id)
if is_user_fed_owner(fed_id, user.id):
msg = update.effective_message
user_id = extract_user(msg, args)
if user_id:
user = bot.get_chat(user_id)
elif not msg.reply_to_message and not args:
user = msg.from_user
elif not msg.reply_to_message and (
not args or
(len(args) >= 1 and not args[0].startswith("@")
and not args[0].isdigit()
and not msg.parse_entities([MessageEntity.TEXT_MENTION]))):
msg.reply_text(tld(chat.id, "common_err_no_user"))
return
else:
LOGGER.warning('error')
if user_id == bot.id:
update.effective_message.reply_text(tld(chat.id,
"feds_demote_bot"))
return
if sql.search_user_in_fed(fed_id, user_id) is False:
update.effective_message.reply_text(
tld(chat.id, "feds_demote_target_not_admin"))
return
res = sql.user_demote_fed(fed_id, user_id)
if res is True:
update.effective_message.reply_text(
tld(chat.id, "feds_demote_success"))
else:
update.effective_message.reply_text(
tld(chat.id, "feds_demote_failed"))
else:
update.effective_message.reply_text(tld(chat.id, "feds_owner_only"))
return
def set_about_bio(bot: Bot, update: Update):
chat = update.effective_chat
message = update.effective_message
sender = update.effective_user
if message.reply_to_message:
repl_message = message.reply_to_message
user_id = repl_message.from_user.id
if user_id in (777000, 1087968824):
message.reply_text(tld(chat.id, 'userinfo_anonymous_bio'))
return
if user_id == message.from_user.id:
message.reply_text(tld(chat.id, 'userinfo_bio_you_cant_set'))
return
elif user_id == bot.id and sender.id not in SUDO_USERS:
message.reply_text(tld(chat.id, 'userinfo_bio_bot_sudo_only'))
return
elif user_id in SUDO_USERS and sender.id not in SUDO_USERS:
message.reply_text(tld(chat.id, 'userinfo_bio_sudo_sudo_only'))
return
elif user_id == OWNER_ID:
message.reply_text(tld(chat.id, 'userinfo_bio_owner_nobio'))
return
text = message.text
bio = text.split(
None, 1
) # use python's maxsplit to only remove the cmd, hence keeping newlines.
if len(bio) == 2:
if len(bio[1]) < MAX_MESSAGE_LENGTH // 4:
sql.set_user_bio(user_id, bio[1])
message.reply_text("Updated {}'s bio!".format(
repl_message.from_user.first_name))
else:
message.reply_text(
tld(chat.id, 'userinfo_bio_too_long').format(
MAX_MESSAGE_LENGTH // 4, len(bio[1])))
else:
message.reply_text(tld(chat.id, 'userinfo_bio_set_no_reply'))
def unban(bot: Bot, update: Update, args: List[str]) -> str:
message = update.effective_message # type: Optional[Message]
user = update.effective_user # type: Optional[User]
chat = update.effective_chat # type: Optional[Chat]
user_id, reason = extract_user_and_text(message, args)
if user_can_ban(chat, user, bot.id) is False:
message.reply_text(tld(chat.id, "admin_no_ban_perm"))
return ""
if not user_id:
return ""
try:
member = chat.get_member(user_id)
except BadRequest as excp:
if excp.message == "User not found":
message.reply_text(tld(chat.id, "common_err_no_user"))
return ""
else:
raise
if is_user_in_chat(chat, user_id):
message.reply_text(tld(chat.id, "bans_unban_user_in_chat"))
return ""
chat.unban_member(user_id)
message.reply_text(tld(chat.id, "bans_unban_success"))
log = tld(chat.id, "bans_unban_logger").format(
html.escape(chat.title), mention_html(user.id, user.first_name),
mention_html(member.user.id, member.user.first_name), member.user.id)
if reason:
log += tld(chat.id, "bans_logger_reason").format(reason)
return log
async def los(c: Client, update: Update):
chat_id = update.chat.id,
try:
device = update.command[1]
except Exception:
device = ''
if device == '':
reply_text = tld(chat_id, "cmd_example").format("los")
await update.reply_text(reply_text, disable_web_page_preview=True)
return
fetch = get(f'https://download.lineageos.org/api/v1/{device}/nightly/*')
if fetch.status_code == 200 and len(fetch.json()['response']) != 0:
usr = json.loads(fetch.content)
response = usr['response'][0]
filename = response['filename']
url = response['url']
buildsize_a = response['size']
buildsize_b = sizee(int(buildsize_a))
version = response['version']
reply_text = tld(chat_id, "download").format(filename, url)
reply_text += tld(chat_id, "build_size").format(buildsize_b)
reply_text += tld(chat_id, "version").format(version)
btn = tld(chat_id, "btn_dl")
keyboard = [[InlineKeyboardButton(text=btn, url=url)]]
await update.reply_text(reply_text,
reply_markup=InlineKeyboardMarkup(keyboard),
disable_web_page_preview=True)
return
else:
reply_text = tld(chat_id, "err_not_found")
await update.reply_text(reply_text, disable_web_page_preview=True)
async def los(event):
if event.from_id is None:
return
chat_id = event.chat_id
try:
device_ = event.pattern_match.group(1)
device = urllib.parse.quote_plus(device_)
except Exception:
device = ''
if device == '':
reply_text = tld(chat_id, "cmd_example").format("los")
await event.reply(reply_text, link_preview=False)
return
fetch = get(f'https://download.lineageos.org/api/v1/{device}/nightly/*')
if fetch.status_code == 200 and len(fetch.json()['response']) != 0:
usr = json.loads(fetch.content)
response = usr['response'][0]
filename = response['filename']
url = response['url']
buildsize_a = response['size']
buildsize_b = sizee(int(buildsize_a))
version = response['version']
reply_text = tld(chat_id, "download").format(filename, url)
reply_text += tld(chat_id, "build_size").format(buildsize_b)
reply_text += tld(chat_id, "version").format(version)
keyboard = [custom.Button.url(tld(chat_id, "btn_dl"), f"{url}")]
await event.reply(reply_text, buttons=keyboard, link_preview=False)
return
else:
reply_text = tld(chat_id, "err_not_found")
await event.reply(reply_text, link_preview=False)
