{x}\n"
- if text == "":
+ if not text:
text = "No commands are currently ignored from bluetext cleaning."
message.reply_text(text)
return
diff --git a/AstrakoBot/modules/clear_cmd.py b/AstrakoBot/modules/clear_cmd.py
index 75644a6729..63be30c39a 100644
--- a/AstrakoBot/modules/clear_cmd.py
+++ b/AstrakoBot/modules/clear_cmd.py
@@ -4,7 +4,7 @@
import AstrakoBot.modules.sql.clear_cmd_sql as sql
from AstrakoBot import dispatcher
from AstrakoBot.modules.helper_funcs.chat_status import user_admin, connection_status
-
+from AstrakoBot.modules.helper_funcs.string_handling import parse_to_seconds
@user_admin
@connection_status
@@ -28,7 +28,7 @@ def clearcmd(update: Update, context: CallbackContext):
"lyrics",
"magisk",
"miui",
- "notes",
+ "notes",
"orangefox",
"phh",
"ping",
@@ -53,7 +53,7 @@ def clearcmd(update: Update, context: CallbackContext):
if commands:
msg += "*Command - Time*\n"
for cmd in commands:
- msg += f"`{cmd.cmd} - {cmd.time} secs`\n"
+ msg += f"`{cmd.cmd} - {cmd.time} secs`\n"
else:
msg = f"No deletion time has been set for any command in *{chat.title}*"
@@ -83,14 +83,17 @@ def clearcmd(update: Update, context: CallbackContext):
if time == "restore":
sql.del_clearcmd(chat.id, cmd)
msg = f"Removed `{cmd}` from list"
- elif (5 <= int(time) <= 300):
- sql.set_clearcmd(chat.id, cmd, time)
- msg = f"`{cmd}` output will be deleted after *{time}* seconds in *{chat.title}*"
else:
- msg = "Time must be between 5 and 300 seconds"
+ time = parse_to_seconds(time)
+ if not time:
+ msg = "Time must be in seconds or minutes"
+ elif (5 <= time <= 300):
+ sql.set_clearcmd(chat.id, cmd, time)
+ msg = f"`{cmd}` output will be deleted after *{time}* seconds in *{chat.title}*"
+ else:
+ msg = "Time must be between 5 and 300 seconds"
else:
msg = "Specify a valid command. Use `/clearcmd list` to see available commands"
-
else:
msg = "I don't understand what are you trying to do. Check module help for more details"
diff --git a/AstrakoBot/modules/cron_jobs.py b/AstrakoBot/modules/cron_jobs.py
new file mode 100644
index 0000000000..92c7e43888
--- /dev/null
+++ b/AstrakoBot/modules/cron_jobs.py
@@ -0,0 +1,117 @@
+import glob
+import os
+import shutil
+import datetime
+import subprocess
+from time import sleep
+from telegram.ext.commandhandler import CommandHandler
+
+from telegram.update import Update
+from telegram.ext.callbackcontext import CallbackContext
+
+from AstrakoBot import DB_NAME, OWNER_ID, dispatcher, LOGGER as log, BACKUP_PASS
+from AstrakoBot.modules.helper_funcs.chat_status import owner_plus
+
+@owner_plus
+def backup_now(_: Update, ctx: CallbackContext):
+ cronjob.run(dispatcher=dispatcher)
+
+@owner_plus
+def stop_jobs(update: Update, _: CallbackContext):
+ print(j.stop())
+ update.effective_message.reply_text("Scheduler has been shut down")
+
+@owner_plus
+def start_jobs(update: Update, _: CallbackContext):
+ print(j.start())
+ update.effective_message.reply_text("Scheduler started")
+
+zip_pass = BACKUP_PASS
+
+def backup_db(_: CallbackContext):
+ bot = dispatcher.bot
+ tmpmsg = "Performing backup, Please wait..."
+ tmp = bot.send_message(OWNER_ID, tmpmsg)
+ datenow = datetime.datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
+ dbbkpname = "db_{}_{}.tar".format(bot.username, datenow)
+ bkplocation = "backups/{}".format(datenow)
+ bkpcmd = "pg_dump {} --format=tar > {}/{}".format(DB_NAME, bkplocation, dbbkpname)
+
+ if not os.path.exists(bkplocation):
+ os.makedirs(bkplocation)
+ log.info("performing db backup")
+ loginfo = "db backup"
+ term(bkpcmd, loginfo)
+ if not os.path.exists('{}/{}'.format(bkplocation, dbbkpname)):
+ bot.send_message(OWNER_ID, "An error occurred during the db backup")
+ tmp.edit_text("Backup Failed!")
+ sleep(8)
+ tmp.delete()
+ return
+ else:
+ log.info("copying config, and logs to backup location")
+ if os.path.exists('log.txt'):
+ print("logs copied")
+ shutil.copyfile('log.txt', '{}/log.txt'.format(bkplocation))
+ if os.path.exists('AstrakoBot/config.py'):
+ print("config copied")
+ shutil.copyfile('AstrakoBot/config.py', '{}/config.py'.format(bkplocation))
+ log.info("zipping the backup")
+ zipcmd = "zip -s 45m --password '{}' {} {}/*".format(zip_pass, bkplocation, bkplocation)
+ zipinfo = "zipping db backup"
+ log.info("zip started")
+ term(zipcmd, zipinfo)
+ log.info("zip done")
+ sleep(1)
+ for file in glob.glob('backups/{}'.format(f'{datenow}.z*')):
+ with open(file, 'rb') as bkp:
+ nm = "{} backup \n".format(bot.username) + datenow
+ try:
+ bot.send_document(OWNER_ID,
+ document=bkp,
+ caption=nm,
+ timeout=20
+ )
+ except Exception as err:
+ bot.send_message(OWNER_ID, "Failed to send backup:\n {}".format(err))
+ log.info("removing zipped files")
+ shutil.rmtree("backups/{}".format(datenow))
+ for file in glob.glob('backups/{}'.format(f'202*.z*')):
+ if os.path.isfile(file) \
+ and os.path.getmtime(file) < (datetime.datetime.now() - datetime.timedelta(days=5)).timestamp():
+ os.remove(file)
+
+ log.info("backup done")
+ tmp.edit_text("Backup complete!")
+ sleep(5)
+ tmp.delete()
+
+@owner_plus
+def del_bkp_fldr(update: Update, _: CallbackContext):
+ shutil.rmtree("backups")
+ update.effective_message.reply_text("'backups' directory has been purged!")
+
+def term(cmd, info):
+ process = subprocess.Popen(
+ cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True
+ )
+ stdout, stderr = process.communicate()
+ stderr = stderr.decode()
+ stdout = stdout.decode()
+ if stdout:
+ log.info(f"{info} successful!")
+ log.info(f"{stdout}")
+ if stderr:
+ log.error(f"error while running {info}")
+ log.info(f"{stderr}")
+
+from AstrakoBot import updater as u
+# run the backup daliy at 1:00
+twhen = datetime.datetime.strptime('01:00', '%H:%M').time()
+j = u.job_queue
+cronjob = j.run_daily(callback=backup_db, name="database backups", time=twhen)
+
+dispatcher.add_handler(CommandHandler("backupdb", backup_now, run_async=True))
+dispatcher.add_handler(CommandHandler("stopjobs", stop_jobs, run_async=True))
+dispatcher.add_handler(CommandHandler("startjobs", start_jobs, run_async=True))
+dispatcher.add_handler(CommandHandler("purgebackups", del_bkp_fldr, run_async=True))
diff --git a/AstrakoBot/modules/currency_converter.py b/AstrakoBot/modules/currency_converter.py
index cd0acccafb..7453e72c90 100644
--- a/AstrakoBot/modules/currency_converter.py
+++ b/AstrakoBot/modules/currency_converter.py
@@ -5,7 +5,6 @@
from AstrakoBot.modules.sql.clear_cmd_sql import get_clearcmd
from AstrakoBot.modules.helper_funcs.misc import delete
-
def convert(update: Update, context: CallbackContext):
chat = update.effective_chat
args = update.effective_message.text.split(" ")
@@ -13,30 +12,52 @@ def convert(update: Update, context: CallbackContext):
if len(args) == 4:
try:
orig_cur_amount = float(args[1])
-
except ValueError:
update.effective_message.reply_text("Invalid amount of currency")
return
orig_cur = args[2].upper()
-
new_cur = args[3].upper()
+ api_version = "v6"
+ data = None
- request_url = (
- f"https://www.alphavantage.co/query"
- f"?function=CURRENCY_EXCHANGE_RATE"
- f"&from_currency={orig_cur}"
- f"&to_currency={new_cur}"
- f"&apikey={CASH_API_KEY}"
- )
- response = requests.get(request_url).json()
try:
- current_rate = float(
- response["Realtime Currency Exchange Rate"]["5. Exchange Rate"]
- )
- except KeyError:
- update.effective_message.reply_text("Currency not supported.")
+ request_url = f"https://v6.exchangerate-api.com/v6/{CASH_API_KEY}/latest/{orig_cur}"
+ response = requests.get(request_url)
+ data = response.json()
+
+ if data.get('result') == 'error':
+ api_version = "v4"
+ request_url = f"https://api.exchangerate-api.com/v4/latest/{orig_cur}"
+ response = requests.get(request_url)
+ data = response.json()
+
+ except Exception as e:
+ update.effective_message.reply_text(f"API Error: {str(e)}")
+ return
+
+ if not data or 'result' in data and data['result'] == 'error':
+ error_key = 'error_type' if api_version == "v4" else 'error-type'
+ error_msg = data.get(error_key, 'Unknown API error') if data else 'Empty API response'
+ update.effective_message.reply_text(f"Error: {error_msg}")
return
+
+ if api_version == "v6":
+ if not data.get('conversion_rates'):
+ update.effective_message.reply_text("Invalid API response format")
+ return
+ rates = data['conversion_rates']
+ else:
+ if not data.get('rates'):
+ update.effective_message.reply_text("Invalid API response format")
+ return
+ rates = data['rates']
+
+ if new_cur not in rates:
+ update.effective_message.reply_text(f"Currency {new_cur} is not supported.")
+ return
+
+ current_rate = rates[new_cur]
new_cur_amount = round(orig_cur_amount * current_rate, 5)
delmsg = update.effective_message.reply_text(
f"{orig_cur_amount} {orig_cur} = {new_cur_amount} {new_cur}"
@@ -47,16 +68,13 @@ def convert(update: Update, context: CallbackContext):
else:
delmsg = update.effective_message.reply_text(
- f"*Invalid Args!!:* Required 3 but passed {len(args) -1}",
+ f"*Invalid Arguments!* Required 3 parameters but got {len(args)-1}",
parse_mode=ParseMode.MARKDOWN,
)
cleartime = get_clearcmd(chat.id, "cash")
-
if cleartime:
context.dispatcher.run_async(delete, delmsg, cleartime.time)
-
CONVERTER_HANDLER = CommandHandler("cash", convert, run_async=True)
-
dispatcher.add_handler(CONVERTER_HANDLER)
diff --git a/AstrakoBot/modules/cust_filters.py b/AstrakoBot/modules/cust_filters.py
index 145d572762..c6125eba3e 100644
--- a/AstrakoBot/modules/cust_filters.py
+++ b/AstrakoBot/modules/cust_filters.py
@@ -84,7 +84,7 @@ def list_handlers(update: Update, context: CallbackContext):
if len(entry) + len(filter_list) > telegram.MAX_MESSAGE_LENGTH:
deletion(update, context, send_message(
update.effective_message,
- filter_list.format(chat_name),
+ filter_list.replace("{}", chat_name, 1),
parse_mode=telegram.ParseMode.MARKDOWN,
))
filter_list = entry
@@ -93,7 +93,7 @@ def list_handlers(update: Update, context: CallbackContext):
deletion(update, context, send_message(
update.effective_message,
- filter_list.format(chat_name),
+ filter_list.replace("{}", chat_name, 1),
parse_mode=telegram.ParseMode.MARKDOWN,
))
diff --git a/AstrakoBot/modules/debug.py b/AstrakoBot/modules/debug.py
index 7b56b33d7e..82d8806e8c 100644
--- a/AstrakoBot/modules/debug.py
+++ b/AstrakoBot/modules/debug.py
@@ -54,6 +54,10 @@ async def i_do_nothing_yes(event):
@dev_plus
def logs(update: Update, context: CallbackContext):
user = update.effective_user
+ if os.path.getsize('log.txt') > (45 * 1024 * 1024):
+ update.effective_message.reply_text("Log file is too big to be sent!")
+ return
+
with open("log.txt", "rb") as f:
context.bot.send_document(document=f, filename=f.name, chat_id=user.id)
diff --git a/AstrakoBot/modules/disable.py b/AstrakoBot/modules/disable.py
index f7f7f9af85..2921b1f432 100644
--- a/AstrakoBot/modules/disable.py
+++ b/AstrakoBot/modules/disable.py
@@ -22,9 +22,9 @@
from AstrakoBot.modules.helper_funcs.chat_status import (
connection_status,
- is_user_admin,
user_admin,
)
+ from AstrakoBot.modules.helper_funcs.admin_status import user_is_admin
from AstrakoBot.modules.sql import disable_sql as sql
from telegram.ext.dispatcher import run_async
@@ -65,7 +65,7 @@ def check_update(self, update):
return None
chat = update.effective_chat
user = update.effective_user
- if user.id == 1087968824:
+ if not user.id or user.id == 1087968824:
user_id = chat.id
else:
user_id = user.id
@@ -78,7 +78,7 @@ def check_update(self, update):
# check if command was disabled
is_disabled = command[
0
- ] in ADMIN_CMDS and is_user_admin(chat, user.id)
+ ] in ADMIN_CMDS and user_is_admin(chat, user.id)
if not is_disabled:
return None
else:
diff --git a/AstrakoBot/modules/feds.py b/AstrakoBot/modules/feds.py
index cafe5fc48b..4fc667490c 100644
--- a/AstrakoBot/modules/feds.py
+++ b/AstrakoBot/modules/feds.py
@@ -6,6 +6,7 @@
import time
import uuid
from io import BytesIO
+from html import escape
import AstrakoBot.modules.sql.feds_sql as sql
from AstrakoBot import (
@@ -18,9 +19,9 @@
dispatcher,
)
from AstrakoBot.modules.disable import DisableAbleCommandHandler
+from AstrakoBot.modules.helper_funcs.admin_status import get_bot_member, user_is_admin
from AstrakoBot.modules.helper_funcs.alternate import send_message
from AstrakoBot.modules.helper_funcs.chat_status import (
- is_user_admin,
can_delete,
)
from AstrakoBot.modules.helper_funcs.extraction import (
@@ -28,9 +29,10 @@
extract_user,
extract_user_fban,
)
+from AstrakoBot.modules.helper_funcs.admin_status import user_is_admin
from AstrakoBot.modules.helper_funcs.string_handling import markdown_parser
from telegram import (
- InlineKeyboardButton,
+ Chat, InlineKeyboardButton,
InlineKeyboardMarkup,
MessageEntity,
ParseMode,
@@ -41,7 +43,7 @@
CallbackContext,
CallbackQueryHandler,
CommandHandler,
- run_async,
+ Filters, MessageHandler, run_async,
)
from telegram.utils.helpers import mention_html, mention_markdown
@@ -54,6 +56,7 @@
# Time spended on updating version to v2 = 26+ hours by @AyraHikari
# Total spended for making this features is 68+ hours
# LOGGER.info("Original federation module by MrYacha, reworked by Mizukito Akito (@peaktogoo) on Telegram.")
+from AstrakoBot.modules.sql.users_sql import get_user_com_chats
FBAN_ERRORS = {
"User is an administrator of the chat",
@@ -92,13 +95,13 @@ def new_fed(update: Update, context: CallbackContext):
"Federations can only be created by privately messaging me."
)
return
- if len(message.text) == 1:
+ if not context.args:
send_message(
update.effective_message, "Please write the name of the federation!"
)
return
fednam = message.text.split(None, 1)[1]
- if not fednam == "":
+ if fednam:
fed_id = str(uuid.uuid4())
fed_name = fednam
LOGGER.info(fed_id)
@@ -125,7 +128,7 @@ def new_fed(update: Update, context: CallbackContext):
try:
bot.send_message(
EVENT_LOGS,
- "New Federation: {}\nID: {}".format(fed_name, fed_id),
+ "New Federation: {}\nID: {}".format(escape(str(fed_name)), fed_id),
parse_mode=ParseMode.HTML,
)
except:
@@ -210,7 +213,7 @@ def fed_chat(update: Update, context: CallbackContext):
fed_id = sql.get_fed_id(chat.id)
user_id = update.effective_message.from_user.id
- if not is_user_admin(update.effective_chat, user_id):
+ if not user_is_admin(update.effective_chat, user_id):
update.effective_message.reply_text(
"You must be an admin to execute this command"
)
@@ -225,7 +228,7 @@ def fed_chat(update: Update, context: CallbackContext):
info = sql.get_fed_info(fed_id)
text = "This group is part of the following federation:"
- text += "\n{} (ID: {})".format(info["fname"], fed_id)
+ text += "\n{} (ID: {})".format(escape(str(info["fname"])), fed_id)
update.effective_message.reply_text(text, parse_mode=ParseMode.HTML)
@@ -350,25 +353,18 @@ def user_join_fed(update: Update, context: CallbackContext):
if is_user_fed_owner(fed_id, user.id) or user.id in SUDO_USERS:
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("I cannot extract user from this message")
+ if not user_id:
+ msg.reply_text("Who are you trying to promote?")
return
- else:
- LOGGER.warning("error")
+ user = bot.get_chat(user_id)
+
getuser = sql.search_user_in_fed(fed_id, user_id)
fed_id = sql.get_fed_id(chat.id)
+ if not fed_id:
+ update.effective_message.reply_text(
+ "This group is not in any federation!"
+ )
+ return
info = sql.get_fed_info(fed_id)
get_owner = ast.literal_eval(info["fusers"])["owner"]
get_owner = bot.get_chat(get_owner).id
@@ -410,28 +406,13 @@ def user_demote_fed(update: Update, context: CallbackContext):
fed_id = sql.get_fed_id(chat.id)
- if is_user_fed_owner(fed_id, user.id):
+ if is_user_fed_owner(fed_id, user.id) or user.id in SUDO_USERS:
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("I cannot extract user from this message")
+ if not user_id:
+ msg.reply_text("Who are you trying to demote?")
return
- else:
- LOGGER.warning("error")
+ user = bot.get_chat(user_id)
if user_id == bot.id:
update.effective_message.reply_text(
@@ -476,10 +457,6 @@ def fed_info(update: Update, context: CallbackContext):
return
info = sql.get_fed_info(fed_id)
- if is_user_fed_admin(fed_id, user.id) is False:
- update.effective_message.reply_text("Only a federation admin can do this!")
- return
-
owner = bot.get_chat(info["owner"])
try:
owner_name = owner.first_name + " " + owner.last_name
@@ -494,7 +471,7 @@ def fed_info(update: Update, context: CallbackContext):
text = "ā¹ļø Federation Information:"
text += "\nFedID: {}".format(fed_id)
- text += "\nName: {}".format(info["fname"])
+ text += "\nName: {}".format(escape(str(info["fname"])))
text += "\nCreator: {}".format(mention_html(owner.id, owner_name))
text += "\nAll Admins: {}".format(TotalAdminFed)
getfban = sql.get_all_fban_users(fed_id)
@@ -533,31 +510,45 @@ def fed_admin(update: Update, context: CallbackContext):
chat = update.effective_chat
info = sql.get_fed_info(fed_id)
- text = "Federation Admin {}:\n\n".format(info["fname"])
+ text = "Federation Admin {}:\n\n".format(escape(str(info["fname"])))
text += "š Owner:\n"
owner = bot.get_chat(info["owner"])
try:
owner_name = owner.first_name + " " + owner.last_name
- except:
- owner_name = owner.first_name
- text += " ā¢ {}\n".format(mention_html(owner.id, owner_name))
+ except BaseException:
+ owner_name = owner.first_name or 'Deleted'
+ text += " ā¢ {} ({})\n".format(mention_html(owner.id, owner_name), escape(str(owner.id)))
members = sql.all_fed_members(fed_id)
+ zombies = []
if len(members) == 0:
text += "\nš± There are no admins in this federation"
else:
text += "\nš± Admin:\n"
for x in members:
- user = bot.get_chat(x)
- text += " ā¢ {}\n".format(mention_html(user.id, user.first_name))
+ try:
+ user = bot.get_chat(x)
+ except BadRequest:
+ continue
+
+ if not user.first_name:
+ zombies.append(user.id)
+ continue
+ text += " ā¢ {} ({})\n".format(mention_html(user.id, user.first_name), escape(str(user.id)))
+
+ if zombies:
+ text += "\nš§ Zombies:\n"
+ for user_id in zombies:
+ text += " ā¢ {}\n".format(escape(str(user_id)))
update.effective_message.reply_text(text, parse_mode=ParseMode.HTML)
def fed_ban(update: Update, context: CallbackContext):
- bot, args = context.bot, context.args
- chat = update.effective_chat
- user = update.effective_user
+ bot, args = context.bot, context.args # type: telegram.Bot, List[str]
+ chat = update.effective_chat # Type: Optional[Chat]
+ user = update.effective_user # Type: Optional[User]
+ silent: bool = False
if chat.type == "private":
send_message(
@@ -591,6 +582,12 @@ def fed_ban(update: Update, context: CallbackContext):
message.reply_text("You don't seem to be referring to a user")
return
+ if not reason:
+ message.reply_text(
+ "You must provide a reason!"
+ )
+ return
+
if user_id == bot.id:
message.reply_text(
"What is funnier than kicking the group creator? Self sacrifice."
@@ -632,7 +629,7 @@ def fed_ban(update: Update, context: CallbackContext):
if not str(user_id).isdigit():
send_message(update.effective_message, excp.message)
return
- elif len(str(user_id)) != 9:
+ elif len(str(user_id)) not in [9, 10]:
send_message(update.effective_message, "That's not a user!")
return
isvalid = False
@@ -656,7 +653,7 @@ def fed_ban(update: Update, context: CallbackContext):
# starting = "The reason fban is replaced for {} in the Federation {}.".format(user_target, fed_name)
# send_message(update.effective_message, starting, parse_mode=ParseMode.HTML)
- # if reason == "":
+ # if not reason:
# reason = "No reason given."
temp = sql.un_fban_user(fed_id, fban_user_id)
@@ -688,7 +685,7 @@ def fed_ban(update: Update, context: CallbackContext):
"\nUser: {}"
"\nUser ID: {}"
"\nReason: {}".format(
- fed_name,
+ escape(str(fed_name)),
mention_html(user.id, user.first_name),
user_target,
fban_user_id,
@@ -698,33 +695,33 @@ def fed_ban(update: Update, context: CallbackContext):
)
# Send message to owner if fednotif is enabled
if getfednotif:
- bot.send_message(
- info["owner"],
- "FedBan reason updated"
- "\nFederation: {}"
- "\nFederation Admin: {}"
- "\nUser: {}"
- "\nUser ID: {}"
- "\nReason: {}".format(
- fed_name,
- mention_html(user.id, user.first_name),
- user_target,
- fban_user_id,
- reason,
- ),
- parse_mode="HTML",
- )
+ try:
+ bot.send_message(
+ info["owner"],
+ "FedBan reason updated"
+ "\nFederation: {}"
+ "\nFederation Admin: {}"
+ "\nUser: {}"
+ "\nUser ID: {}"
+ "\nReason: {}".format(
+ escape(str(fed_name)),
+ mention_html(user.id, user.first_name),
+ user_target,
+ fban_user_id,
+ reason,
+ ),
+ parse_mode="HTML",
+ )
+ except Unauthorized:
+ pass
if message.text.startswith("/s"):
silent = True
if not can_delete(chat, context.bot.id):
return ""
- else:
- silent = False
# If fedlog is set, then send message, except fedlog is current chat
- get_fedlog = sql.get_fed_log(fed_id)
- if get_fedlog:
+ if get_fedlog := sql.get_fed_log(fed_id):
if int(get_fedlog) != int(chat.id):
bot.send_message(
get_fedlog,
@@ -734,7 +731,7 @@ def fed_ban(update: Update, context: CallbackContext):
"\nUser: {}"
"\nUser ID: {}"
"\nReason: {}".format(
- fed_name,
+ escape(str(fed_name)),
mention_html(user.id, user.first_name),
user_target,
fban_user_id,
@@ -742,7 +739,17 @@ def fed_ban(update: Update, context: CallbackContext):
),
parse_mode="HTML",
)
+ common_chats = get_user_com_chats(fban_user_id)
for fedschat in fed_chats:
+ if fedschat not in common_chats:
+ continue
+ if not get_bot_member(fedschat).can_restrict_members:
+ sql.chat_leave_fed(fedschat)
+ bot.send_message(
+ chat.id,
+ "I don't have rights to restrict users on this chat, left fed!",
+ )
+ continue
try:
# Do not spam all fed chats
"""
@@ -751,9 +758,9 @@ def fed_ban(update: Update, context: CallbackContext):
"\nFederation Admin: {}" \
"\nUser: {}" \
"\nUser ID: {}" \
- "\nReason: {}".format(fed_name, mention_html(user.id, user.first_name), user_target, fban_user_id, reason), parse_mode="HTML")
+ "\nReason: {}".format(escape(str(fed_name)), mention_html(user.id, user.first_name), user_target, fban_user_id, reason), parse_mode="HTML")
"""
- bot.kick_chat_member(fedschat, fban_user_id)
+ bot.ban_chat_member(fedschat, fban_user_id)
except BadRequest as excp:
if excp.message in FBAN_ERRORS:
try:
@@ -767,13 +774,25 @@ def fed_ban(update: Update, context: CallbackContext):
)
continue
elif excp.message == "User_id_invalid":
+ LOGGER.debug(
+ "fban error\nUnable to fban user {} in fed {} in chat {} \n\nreason: {}".format(
+ fban_user_id, fed_id, chat.id, str(excp))
+ )
break
else:
LOGGER.warning(
- "Could not fban on {} because: {}".format(chat, excp.message)
+ "Couldn't fban user {} in fed {} in chat {} \n\nreason: {}".format(fban_user_id, fed_id, chat.id, str(excp))
)
- except TelegramError:
+ except TelegramError as e:
+ LOGGER.debug(
+ "fban error, (TelegramError)\nUnable to fban user {} in fed {} in chat {} \n\nreason: {}".format(
+ fban_user_id, fed_id, chat.id, str(e))
+ )
pass
+ except Exception as e:
+ LOGGER.warning(
+ "fban error\nUnable to fban user {} in fed {} in chat {} \n\nreason: {}".format(fban_user_id, fed_id, chat.id, str(e))
+ )
# Also do not spam all fed admins
"""
send_to_list(bot, FEDADMIN,
@@ -782,7 +801,7 @@ def fed_ban(update: Update, context: CallbackContext):
"\nFederation Admin: {}" \
"\nUser: {}" \
"\nUser ID: {}" \
- "\nReason: {}".format(fed_name, mention_html(user.id, user.first_name), user_target, fban_user_id, reason),
+ "\nReason: {}".format(escape(str(fed_name)), mention_html(user.id, user.first_name), user_target, fban_user_id, reason),
html=True)
"""
@@ -792,8 +811,17 @@ def fed_ban(update: Update, context: CallbackContext):
for fedsid in subscriber:
all_fedschat = sql.all_fed_chats(fedsid)
for fedschat in all_fedschat:
+ if fedsid not in common_chats:
+ continue
+ if not get_bot_member(fedschat).can_restrict_members:
+ sql.chat_leave_fed(fedschat)
+ bot.send_message(
+ chat.id,
+ "I don't have rights to restrict users on this chat, left fed!",
+ )
+ continue
try:
- bot.kick_chat_member(fedschat, fban_user_id)
+ bot.ban_chat_member(fedschat, fban_user_id)
except BadRequest as excp:
if excp.message in FBAN_ERRORS:
try:
@@ -808,6 +836,10 @@ def fed_ban(update: Update, context: CallbackContext):
)
continue
elif excp.message == "User_id_invalid":
+ LOGGER.debug(
+ "fban error\nUnable to fban user {} in fed {} in chat {} \n\nreason: {}".format(
+ fban_user_id, fed_id, chat.id, str(excp))
+ )
break
else:
LOGGER.warning(
@@ -815,9 +847,25 @@ def fed_ban(update: Update, context: CallbackContext):
fedschat, excp.message
)
)
- except TelegramError:
+ except TelegramError as e:
+ LOGGER.debug(
+ "fban error, (TelegramError)\nUnable to fban user {} in fed {} in chat {} \n\nreason: {}".format(
+ fban_user_id, fed_id, chat.id, str(e))
+ )
pass
+ except Exception as e:
+ LOGGER.warning(
+ "fban error\nUnable to fban user {} in fed {} in chat {} \n\nreason: {}".format(
+ fban_user_id, fed_id, chat.id, str(e))
+ )
# send_message(update.effective_message, "Fedban Reason has been updated.")
+ if silent:
+ try:
+ if message.reply_to_message:
+ message.reply_to_message.delete()
+ message.delete()
+ except:
+ pass
return
fed_name = info["fname"]
@@ -826,7 +874,7 @@ def fed_ban(update: Update, context: CallbackContext):
# user_target, fed_name)
# update.effective_message.reply_text(starting, parse_mode=ParseMode.HTML)
- # if reason == "":
+ # if not reason:
# reason = "No reason given."
x = sql.fban_user(
@@ -854,7 +902,7 @@ def fed_ban(update: Update, context: CallbackContext):
"\nUser: {}"
"\nUser ID: {}"
"\nReason: {}".format(
- fed_name,
+ escape(str(fed_name)),
mention_html(user.id, user.first_name),
user_target,
fban_user_id,
@@ -867,30 +915,31 @@ def fed_ban(update: Update, context: CallbackContext):
silent = True
if not can_delete(chat, context.bot.id):
return ""
- else:
- silent = False
# Send message to owner if fednotif is enabled
if getfednotif:
- bot.send_message(
- info["owner"],
- "New FedBan"
- "\nFederation: {}"
- "\nFederation Admin: {}"
- "\nUser: {}"
- "\nUser ID: {}"
- "\nReason: {}".format(
- fed_name,
- mention_html(user.id, user.first_name),
- user_target,
- fban_user_id,
- reason,
- ),
- parse_mode="HTML",
- )
+ try:
+ bot.send_message(
+ info["owner"],
+ "New FedBan"
+ "\nFederation: {}"
+ "\nFederation Admin: {}"
+ "\nUser: {}"
+ "\nUser ID: {}"
+ "\nReason: {}".format(
+ escape(str(fed_name)),
+ mention_html(user.id, user.first_name),
+ user_target,
+ fban_user_id,
+ reason,
+ ),
+ parse_mode="HTML",
+ )
+ except Unauthorized:
+ pass
+
# If fedlog is set, then send message, except fedlog is current chat
- get_fedlog = sql.get_fed_log(fed_id)
- if get_fedlog:
+ if get_fedlog:= sql.get_fed_log(fed_id):
if int(get_fedlog) != int(chat.id):
bot.send_message(
get_fedlog,
@@ -900,7 +949,7 @@ def fed_ban(update: Update, context: CallbackContext):
"\nUser: {}"
"\nUser ID: {}"
"\nReason: {}".format(
- fed_name,
+ escape(str(fed_name)),
mention_html(user.id, user.first_name),
user_target,
fban_user_id,
@@ -908,9 +957,19 @@ def fed_ban(update: Update, context: CallbackContext):
),
parse_mode="HTML",
)
- chats_in_fed = 0
+ # chats_in_fed = 0
+ common_chats = get_user_com_chats(fban_user_id)
for fedschat in fed_chats:
- chats_in_fed += 1
+ if fedschat not in common_chats:
+ continue
+ if not get_bot_member(fedschat).can_restrict_members:
+ sql.chat_leave_fed(fedschat)
+ bot.send_message(
+ chat.id,
+ "I don't have rights to restrict users on this chat, left fed!",
+ )
+ continue
+ # chats_in_fed += 1
try:
# Do not spamming all fed chats
"""
@@ -919,20 +978,33 @@ def fed_ban(update: Update, context: CallbackContext):
"\nFederation Admin: {}" \
"\nUser: {}" \
"\nUser ID: {}" \
- "\nReason: {}".format(fed_name, mention_html(user.id, user.first_name), user_target, fban_user_id, reason), parse_mode="HTML")
+ "\nReason: {}".format(escape(str(fed_name)), mention_html(user.id, user.first_name), user_target, fban_user_id, reason), parse_mode="HTML")
"""
- bot.kick_chat_member(fedschat, fban_user_id)
+ bot.ban_chat_member(fedschat, fban_user_id)
except BadRequest as excp:
if excp.message in FBAN_ERRORS:
pass
elif excp.message == "User_id_invalid":
- break
+ LOGGER.debug(
+ "fban error\nUnable to fban user {} in fed {} in chat {} \n\nreason: {}".format(
+ fban_user_id, fed_id, chat.id, str(excp))
+ )
+ # break
else:
LOGGER.warning(
- "Could not fban on {} because: {}".format(chat, excp.message)
+ "Couldn't fban user {} in fed {} in chat {} \n\nreason: {}".format(fban_user_id, fed_id,
+ chat.id, str(excp))
)
- except TelegramError:
+ except TelegramError as e:
+ LOGGER.debug(
+ "fban error, (TelegramError)\nUnable to fban user {} in fed {} in chat {} \n\nreason: {}".format(
+ fban_user_id, fed_id, chat.id, str(excp))
+ )
pass
+ except Exception as e:
+ LOGGER.warning(
+ "fban error\nUnable to fban user {} in fed {} in chat {} \n\nreason: {}".format(fban_user_id, fed_id, chat.id, str(e))
+ )
# Also do not spamming all fed admins
"""
@@ -942,51 +1014,76 @@ def fed_ban(update: Update, context: CallbackContext):
"\nFederation Admin: {}" \
"\nUser: {}" \
"\nUser ID: {}" \
- "\nReason: {}".format(fed_name, mention_html(user.id, user.first_name), user_target, fban_user_id, reason),
+ "\nReason: {}".format(escape(str(fed_name)), mention_html(user.id, user.first_name), user_target, fban_user_id, reason),
html=True)
"""
- # Fban for fed subscriber
- subscriber = list(sql.get_subscriber(fed_id))
- if len(subscriber) != 0:
- for fedsid in subscriber:
- all_fedschat = sql.all_fed_chats(fedsid)
- for fedschat in all_fedschat:
- try:
- bot.kick_chat_member(fedschat, fban_user_id)
- except BadRequest as excp:
- if excp.message in FBAN_ERRORS:
- try:
- dispatcher.bot.getChat(fedschat)
- except Unauthorized:
- targetfed_id = sql.get_fed_id(fedschat)
- sql.unsubs_fed(fed_id, targetfed_id)
- LOGGER.info(
- "Chat {} has unsubbed from the fed {} because I was kicked".format(
- fedschat, info["fname"]
- )
- )
- continue
- elif excp.message == "User_id_invalid":
- break
- else:
- LOGGER.warning(
- "Unable to execute fban on {} because: {}".format(
- fedschat, excp.message
+ # Fban for fed subscriber
+ subscriber = list(sql.get_subscriber(fed_id))
+ if len(subscriber) != 0:
+ for fedsid in subscriber:
+ all_fedschat = sql.all_fed_chats(fedsid)
+ for fedschat in all_fedschat:
+ if fedsid not in common_chats:
+ continue
+ if not get_bot_member(fedschat).can_restrict_members:
+ sql.chat_leave_fed(fedschat)
+ bot.send_message(
+ chat.id,
+ "I don't have rights to restrict users on this chat, left fed!",
+ )
+ continue
+ try:
+ bot.ban_chat_member(fedschat, fban_user_id)
+ except BadRequest as excp:
+ if excp.message in FBAN_ERRORS:
+ try:
+ dispatcher.bot.getChat(fedschat)
+ except Unauthorized:
+ targetfed_id = sql.get_fed_id(fedschat)
+ sql.unsubs_fed(fed_id, targetfed_id)
+ LOGGER.info(
+ "Chat {} has unsubbed from the fed {} because I was kicked".format(
+ fedschat, info["fname"]
)
)
- except TelegramError:
- pass
+ continue
+ elif excp.message == "User_id_invalid":
+ LOGGER.debug(
+ "fban error\nUnable to fban user {} in fed {} in chat {} \n\nreason: {}".format(
+ fban_user_id, fed_id, chat.id, str(excp))
+ )
+ break
+ else:
+ LOGGER.warning(
+ "Unable to execute fban on {} because: {}".format(
+ fedschat, excp.message
+ )
+ )
+ except TelegramError as e:
+ LOGGER.debug(
+ "fban error, (TelegramError)\nUnable to fban user {} in fed {} in chat {} \n\nreason: {}".format(
+ fban_user_id, fed_id, chat.id, str(e))
+ )
+ pass
+ except Exception as e:
+ LOGGER.warning(
+ "fban error\nUnable to fban user {} in fed {} in chat {} \n\nreason: {}".format(
+ fban_user_id, fed_id, chat.id, str(e))
+ )
# if chats_in_fed == 0:
# send_message(update.effective_message, "Fedban affected 0 chats. ")
# elif chats_in_fed > 0:
# send_message(update.effective_message,
# "Fedban affected {} chats. ".format(chats_in_fed))
-
+
if silent:
- if message.reply_to_message:
- message.reply_to_message.delete()
- message.delete()
+ try:
+ if message.reply_to_message:
+ message.reply_to_message.delete()
+ message.delete()
+ except:
+ pass
return
@@ -1071,7 +1168,7 @@ def unfban(update: Update, context: CallbackContext):
"\nFederation Admin: {}"
"\nUser: {}"
"\nUser ID: {}".format(
- info["fname"],
+ escape(str(info["fname"])),
mention_html(user.id, user.first_name),
user_target,
fban_user_id,
@@ -1080,20 +1177,24 @@ def unfban(update: Update, context: CallbackContext):
)
# Send message to owner if fednotif is enabled
if getfednotif:
- bot.send_message(
- info["owner"],
- "Un-FedBan"
- "\nFederation: {}"
- "\nFederation Admin: {}"
- "\nUser: {}"
- "\nUser ID: {}".format(
- info["fname"],
- mention_html(user.id, user.first_name),
- user_target,
- fban_user_id,
- ),
- parse_mode="HTML",
- )
+ try:
+ bot.send_message(
+ info["owner"],
+ "Un-FedBan"
+ "\nFederation: {}"
+ "\nFederation Admin: {}"
+ "\nUser: {}"
+ "\nUser ID: {}".format(
+ escape(str(info["fname"])),
+ mention_html(user.id, user.first_name),
+ user_target,
+ fban_user_id,
+ ),
+ parse_mode="HTML",
+ )
+ except Unauthorized:
+ pass
+
# If fedlog is set, then send message, except fedlog is current chat
get_fedlog = sql.get_fed_log(fed_id)
if get_fedlog:
@@ -1105,7 +1206,7 @@ def unfban(update: Update, context: CallbackContext):
"\nFederation Admin: {}"
"\nUser: {}"
"\nUser ID: {}".format(
- info["fname"],
+ escape(str(info["fname"])),
mention_html(user.id, user.first_name),
user_target,
fban_user_id,
@@ -1379,7 +1480,7 @@ def fed_ban_list(update: Update, context: CallbackContext):
getfban = sql.get_all_fban_users(fed_id)
if len(getfban) == 0:
update.effective_message.reply_text(
- "The federation ban list of {} is empty".format(info["fname"]),
+ "The federation ban list of {} is empty".format(escape(str(info["fname"]))),
parse_mode=ParseMode.HTML,
)
return
@@ -1476,13 +1577,13 @@ def fed_ban_list(update: Update, context: CallbackContext):
return
text = "{} users have been banned from the federation {}:\n".format(
- len(getfban), info["fname"]
+ len(getfban), escape(str(info["fname"]))
)
for users in getfban:
getuserinfo = sql.get_all_fban_users_target(fed_id, users)
if getuserinfo is False:
text = "There are no users banned from the federation {}".format(
- info["fname"]
+ escape(str(info["fname"]))
)
break
user_name = getuserinfo["first_name"]
@@ -1567,6 +1668,7 @@ def fed_chats(update: Update, context: CallbackContext):
bot, args = context.bot, context.args
chat = update.effective_chat
user = update.effective_user
+ chat_name = ""
if chat.type == "private":
send_message(
@@ -1591,12 +1693,12 @@ def fed_chats(update: Update, context: CallbackContext):
getlist = sql.all_fed_chats(fed_id)
if len(getlist) == 0:
update.effective_message.reply_text(
- "No users are fbanned from the federation {}".format(info["fname"]),
+ "No users are fbanned from the federation {}".format(escape(str(info["fname"]))),
parse_mode=ParseMode.HTML,
)
return
- text = "New chat joined the federation {}:\n".format(info["fname"])
+ text = "New chat joined the federation {}:\n".format(escape(str(info["fname"])))
for chats in getlist:
try:
chat_name = dispatcher.bot.getChat(chats).title
@@ -1608,7 +1710,10 @@ def fed_chats(update: Update, context: CallbackContext):
)
)
continue
- text += " ā¢ {} ({})\n".format(chat_name, chats)
+ except BadRequest as excp:
+ if excp.message in FBAN_ERRORS:
+ pass
+ text += " ā¢ {} ({})\n".format(chat_name, chats)
try:
update.effective_message.reply_text(text, parse_mode=ParseMode.HTML)
@@ -1701,7 +1806,7 @@ def fed_import_bans(update: Update, context: CallbackContext):
reading = file.read().decode("UTF-8")
splitting = reading.split("\n")
for x in splitting:
- if x == "":
+ if not x:
continue
try:
data = json.loads(x)
@@ -1897,7 +2002,7 @@ def fed_stat_user(update: Update, context: CallbackContext):
parse_mode="markdown",
)
return
- if user_name == "" or user_name is None:
+ if not user_name:
user_name = "He/she"
if not reason:
send_message(
@@ -1911,12 +2016,12 @@ def fed_stat_user(update: Update, context: CallbackContext):
send_message(update.effective_message, teks, parse_mode="markdown")
return
user_name, fbanlist = sql.get_user_fbanlist(str(user_id))
- if user_name == "":
+ if not user_name:
try:
user_name = bot.get_chat(user_id).first_name
except BadRequest:
user_name = "He/she"
- if user_name == "" or user_name is None:
+ if not user_name:
user_name = "He/she"
if len(fbanlist) == 0:
send_message(
@@ -1934,7 +2039,7 @@ def fed_stat_user(update: Update, context: CallbackContext):
elif not msg.reply_to_message and not args:
user_id = msg.from_user.id
user_name, fbanlist = sql.get_user_fbanlist(user_id)
- if user_name == "":
+ if not user_name:
user_name = msg.from_user.first_name
if len(fbanlist) == 0:
send_message(
@@ -2273,21 +2378,54 @@ def is_user_fed_owner(fed_id, user_id):
return False
-# There's no handler for this yet, but updating for v12 in case its used
-def welcome_fed(update: Update, context: CallbackContext):
- bot, args = context.bot, context.args
+def enforce_fed(update: Update, ctx: CallbackContext):
chat = update.effective_chat
user = update.effective_user
+ msg = update.effective_message
fed_id = sql.get_fed_id(chat.id)
- fban, fbanreason, fbantime = sql.get_fban_user(fed_id, user.id)
- if fban:
+
+ if fed_id and not get_bot_member(chat.id).can_restrict_members:
+ sql.chat_leave_fed(chat.id)
+ ctx.bot.send_message(
+ chat.id,
+ "I don't have rights to restrict users on this chat, left fed!",
+ )
+ return
+
+ if user and not user_is_admin(chat, user.id):
+ fban, fbanreason, fbantime = sql.get_fban_user(fed_id, user.id)
+ if fban:
+ check_and_ban(update, chat, user.id, fbanreason)
+
+ if msg.new_chat_members:
+ new_members = update.effective_message.new_chat_members
+ for mem in new_members:
+ fban, fbanreason, fbantime = sql.get_fban_user(fed_id, mem.id)
+ if fban:
+ check_and_ban(update, chat, mem.id, fbanreason)
+
+ # this is optional for now because it needs to check if user is in the chat
+ # and I rather not make more requests to tg on every reply
+ # if msg.reply_to_message:
+ # user = msg.reply_to_message.from_user
+ # mem = chat.get_member(user.id)
+ # if mem.status in ["administrator", "creator", "kicked"]:
+ # return
+ # fban, fbanreason, fbantime = sql.get_fban_user(fed_id, user.id)
+ # if fban and user and not user_is_admin(chat, user.id):
+ # check_and_ban(update, chat, user.id, fbanreason)
+
+
+def check_and_ban(update, chat: Chat, user_id: int, reason: str):
+ try:
+ chat.ban_member(user_id)
update.effective_message.reply_text(
- "This user is banned in the current federation! I will remove him."
+ f"This user is banned in the current federation! I will remove him.\n{'Reason: {}'.format(reason) if reason else ''}",
+ allow_sending_without_reply = True
)
- bot.kick_chat_member(chat.id, user.id)
- return True
- else:
- return False
+ except:
+ pass
+
def __stats__():
@@ -2430,6 +2568,8 @@ def fed_user_help(update: Update, context: CallbackContext):
FED_OWNER_HELP_HANDLER = CommandHandler("fedownerhelp", fed_owner_help, run_async=True)
FED_ADMIN_HELP_HANDLER = CommandHandler("fedadminhelp", fed_admin_help, run_async=True)
FED_USER_HELP_HANDLER = CommandHandler("feduserhelp", fed_user_help, run_async=True)
+FBAN_ENFORCE = MessageHandler(Filters.all & Filters.chat_type.groups, enforce_fed, run_async=True)
+
dispatcher.add_handler(NEW_FED_HANDLER)
dispatcher.add_handler(DEL_FED_HANDLER)
@@ -2461,3 +2601,4 @@ def fed_user_help(update: Update, context: CallbackContext):
dispatcher.add_handler(FED_OWNER_HELP_HANDLER)
dispatcher.add_handler(FED_ADMIN_HELP_HANDLER)
dispatcher.add_handler(FED_USER_HELP_HANDLER)
+dispatcher.add_handler(FBAN_ENFORCE, 20)
diff --git a/AstrakoBot/modules/fun.py b/AstrakoBot/modules/fun.py
index 9087412b88..c953cc063a 100644
--- a/AstrakoBot/modules/fun.py
+++ b/AstrakoBot/modules/fun.py
@@ -5,7 +5,7 @@
import AstrakoBot.modules.fun_strings as fun_strings
from AstrakoBot import dispatcher
from AstrakoBot.modules.disable import DisableAbleCommandHandler
-from AstrakoBot.modules.helper_funcs.chat_status import is_user_admin
+from AstrakoBot.modules.helper_funcs.admin_status import user_is_admin
from AstrakoBot.modules.helper_funcs.extraction import extract_user
from AstrakoBot.modules.helper_funcs.misc import delete
from AstrakoBot.modules.sql.clear_cmd_sql import get_clearcmd
@@ -13,8 +13,6 @@
from telegram.error import BadRequest
from telegram.ext import CallbackContext, run_async
-GIF_ID = "CgACAgQAAx0CSVUvGgAC7KpfWxMrgGyQs-GUUJgt-TSO8cOIDgACaAgAAlZD0VHT3Zynpr5nGxsE"
-
def runs(update: Update, context: CallbackContext):
deletion(update, context, update.effective_message.reply_text(random.choice(fun_strings.RUN_STRINGS)))
@@ -27,12 +25,17 @@ def sanitize(update: Update, context: CallbackContext):
if message.reply_to_message
else message.from_user.first_name
)
- reply_animation = (
- message.reply_to_message.reply_animation
+
+ reply_msg = (
+ message.reply_to_message
if message.reply_to_message
- else message.reply_animation
+ else message
)
- deletion(update, context, reply_animation(random.choice(fun_strings.GIFS), caption=f"*Sanitizes {name}*"))
+
+ try:
+ deletion(update, context, reply_msg.reply_animation(random.choice(fun_strings.GIFS), caption=f"*Sanitizes {name}*"))
+ except BadRequest:
+ deletion(update, context, reply_msg.reply_text(f"*Sanitizes {name}*"))
def slap(update: Update, context: CallbackContext):
@@ -54,7 +57,7 @@ def slap(update: Update, context: CallbackContext):
if isinstance(temp, list):
if temp[2] == "tmute":
- if is_user_admin(chat, message.from_user.id):
+ if user_is_admin(chat, message.from_user.id):
reply_text(temp[1])
return
@@ -137,20 +140,6 @@ def roll(update: Update, context: CallbackContext):
deletion(update, context, update.message.reply_text(random.choice(range(1, 7))))
-def shout(update: Update, context: CallbackContext):
- args = context.args
- text = " ".join(args)
- result = []
- result.append(" ".join(list(text)))
- for pos, symbol in enumerate(text[1:]):
- result.append(symbol + " " + " " * pos + symbol)
- result = list("\n".join(result))
- result[0] = text[0]
- result = "".join(result)
- msg = "```\n" + result + "```"
- deletion(update, context, update.effective_message.reply_text(msg, parse_mode="MARKDOWN"))
-
-
def toss(update: Update, context: CallbackContext):
deletion(update, context, update.message.reply_text(random.choice(fun_strings.TOSS)))
@@ -212,90 +201,6 @@ def table(update: Update, context: CallbackContext):
deletion(update, context, reply_text(random.choice(fun_strings.TABLE)))
-normiefont = [
- "a",
- "b",
- "c",
- "d",
- "e",
- "f",
- "g",
- "h",
- "i",
- "j",
- "k",
- "l",
- "m",
- "n",
- "o",
- "p",
- "q",
- "r",
- "s",
- "t",
- "u",
- "v",
- "w",
- "x",
- "y",
- "z",
-]
-weebyfont = [
- "å",
- "ä¹",
- "å",
- "å",
- "ä¹",
- "äø",
- "å¶",
- "å",
- "å·„",
- "äø",
- "éæ",
- "ä¹",
- "ä»",
- "š Ø",
- "å£",
- "å°ø",
- "ćæ",
- "å°ŗ",
- "äø",
- "äø
",
- "åµ",
- "ćŖ",
- "å±±",
- "ä¹",
- "äø«",
- "ä¹",
-]
-
-
-def weebify(update: Update, context: CallbackContext):
- args = context.args
- message = update.effective_message
- string = ""
-
- if message.reply_to_message:
- string = message.reply_to_message.text.lower().replace(" ", " ")
-
- if args:
- string = " ".join(args).lower()
-
- if not string:
- deletion(update, context, message.reply_text("Usage is `/weebify *bans them from here*.\n"
f"Appeal chat: {SPAMWATCH_SUPPORT_CHAT}\n"
f"User ID: {sw_ban.id}\n"
- f"Ban Reason: {html.escape(sw_ban.reason)}",
- parse_mode=ParseMode.HTML,
+ f"Ban Reason: {html.escape(sw_ban.reason)}"
)
+ try:
+ update.effective_message.reply_text(text, parse_mode=ParseMode.HTML)
+ except BadRequest:
+ update.effective_chat.bot.send_message(
+ chat_id=update.effective_chat.id,
+ text=text,
+ parse_mode=ParseMode.HTML
+ )
+
return
if sql.is_user_gbanned(user_id):
- update.effective_chat.kick_member(user_id)
+ update.effective_chat.ban_member(user_id)
if should_message:
text = (
f"Alert: this user is globally banned.\n"
@@ -438,36 +459,38 @@ def check_and_ban(update, user_id, should_message=True):
user = sql.get_gbanned_user(user_id)
if user.reason:
text += f"\nBan Reason: {html.escape(user.reason)}"
- update.effective_message.reply_text(text, parse_mode=ParseMode.HTML)
+ try:
+ update.effective_message.reply_text(text, parse_mode=ParseMode.HTML)
+ except BadRequest:
+ update.effective_chat.bot.send_message(
+ chat_id=update.effective_chat.id,
+ text=text,
+ parse_mode=ParseMode.HTML
+ )
+def enforce_gban(update: Update, _: CallbackContext):
+ chat = update.effective_chat
+ if not get_bot_member(chat.id).can_restrict_members:
+ return
-def enforce_gban(update: Update, context: CallbackContext):
- # Not using @restrict handler to avoid spamming - just ignore if cant gban.
- bot = context.bot
- try:
- restrict_permission = update.effective_chat.get_member(
- bot.id
- ).can_restrict_members
- except Unauthorized:
+ if not sql.does_chat_gban(update.effective_chat.id):
return
- if sql.does_chat_gban(update.effective_chat.id) and restrict_permission:
- user = update.effective_user
- chat = update.effective_chat
- msg = update.effective_message
- if user and not is_user_admin(chat, user.id):
- check_and_ban(update, user.id)
- return
+ user = update.effective_user
+ msg = update.effective_message
+
+ if user and not user_is_admin(chat, user.id):
+ check_and_ban(update, user.id)
- if msg.new_chat_members:
- new_members = update.effective_message.new_chat_members
- for mem in new_members:
- check_and_ban(update, mem.id)
+ if msg.new_chat_members:
+ new_members = update.effective_message.new_chat_members
+ for mem in new_members:
+ check_and_ban(update, mem.id)
- if msg.reply_to_message:
- user = msg.reply_to_message.from_user
- if user and not is_user_admin(chat, user.id):
- check_and_ban(update, user.id, should_message=False)
+ if msg.reply_to_message:
+ user = msg.reply_to_message.from_user
+ if user and not user_is_admin(chat, user.id):
+ check_and_ban(update, user.id, should_message=False)
@user_admin
diff --git a/AstrakoBot/modules/gtranslator.py b/AstrakoBot/modules/gtranslator.py
index 3808860796..5e7390dca0 100644
--- a/AstrakoBot/modules/gtranslator.py
+++ b/AstrakoBot/modules/gtranslator.py
@@ -1,88 +1,162 @@
-from emoji import UNICODE_EMOJI
-from google_trans_new import LANGUAGES, google_translator
from telegram import ParseMode, Update
from telegram.ext import CallbackContext, run_async
+import requests
+import urllib.parse
from AstrakoBot import dispatcher
from AstrakoBot.modules.disable import DisableAbleCommandHandler
from AstrakoBot.modules.helper_funcs.misc import delete
from AstrakoBot.modules.sql.clear_cmd_sql import get_clearcmd
+languages = {
+ "af": "Afrikaans",
+ "sq": "Albanian",
+ "am": "Amharic",
+ "ar": "Arabic",
+ "hy": "Armenian",
+ "az": "Azerbaijani",
+ "eu": "Basque",
+ "be": "Belarusian",
+ "bn": "Bengali",
+ "bs": "Bosnian",
+ "bg": "Bulgarian",
+ "ca": "Catalan",
+ "ceb": "Cebuano",
+ "ny": "Chichewa",
+ "zh-cn": "Chinese",
+ "co": "Corsican",
+ "hr": "Croatian",
+ "cs": "Czech",
+ "da": "Danish",
+ "nl": "Dutch",
+ "en": "English",
+ "eo": "Esperanto",
+ "et": "Estonian",
+ "tl": "Filipino",
+ "fi": "Finnish",
+ "fr": "French",
+ "fy": "Frisian",
+ "gl": "Galician",
+ "ka": "Georgian",
+ "de": "German",
+ "el": "Greek",
+ "gu": "Gujarati",
+ "ht": "Haitian Creole",
+ "ha": "Hausa",
+ "haw": "Hawaiian",
+ "iw": "Hebrew",
+ "hi": "Hindi",
+ "hmn": "Hmong",
+ "hu": "Hungarian",
+ "is": "Icelandic",
+ "ig": "Igbo",
+ "id": "Indonesian",
+ "ga": "Irish",
+ "it": "Italian",
+ "ja": "Japanese",
+ "jw": "Javanese",
+ "kn": "Kannada",
+ "kk": "Kazakh",
+ "km": "Khmer",
+ "rw": "Kinyarwanda",
+ "ko": "Korean",
+ "ku": "Kurdish",
+ "ky": "Kyrgyz",
+ "lo": "Lao",
+ "la": "Latin",
+ "lv": "Latvian",
+ "lt": "Lithuanian",
+ "lb": "Luxembourgish",
+ "mk": "Macedonian",
+ "mg": "Malagasy",
+ "ms": "Malay",
+ "ml": "Malayalam",
+ "mt": "Maltese",
+ "mi": "Maori",
+ "mr": "Marathi",
+ "mn": "Mongolian",
+ "my": "Myanmar",
+ "ne": "Nepali",
+ "no": "Norwegian",
+ "or": "Odia",
+ "ps": "Pashto",
+ "fa": "Persian",
+ "pl": "Polish",
+ "pt": "Portuguese",
+ "pa": "Punjabi",
+ "ro": "Romanian",
+ "ru": "Russian",
+ "sm": "Samoan",
+ "gd": "Scots Gaelic",
+ "sr": "Serbian",
+ "st": "Sesotho",
+ "sn": "Shona",
+ "sd": "Sindhi",
+ "si": "Sinhala",
+ "sk": "Slovak",
+ "sl": "Slovenian",
+ "so": "Somali",
+ "es": "Spanish",
+ "su": "Sundanese",
+ "sw": "Swahili",
+ "sv": "Swedish",
+ "tg": "Tajik",
+ "ta": "Tamil",
+ "tt": "Tatar",
+ "te": "Telugu",
+ "th": "Thai",
+ "tr": "Turkish",
+ "tk": "Turkmen",
+ "uk": "Ukrainian",
+ "ur": "Urdu",
+ "ug": "Uyghur",
+ "uz": "Uzbek",
+ "vi": "Vietnamese",
+ "cy": "Welsh",
+ "xh": "Xhosa",
+ "yi": "Yiddish",
+ "yo": "Yoruba",
+ "zu": "Zulu"
+}
+
+
+def tr(text, srcLang, targetLang):
+ text = urllib.parse.quote_plus(text)
+
+ # Try to get response at least 3 times
+ for _ in range(3):
+ try:
+ response = requests.get("https://translate.googleapis.com/translate_a/single?client=gtx&sl={}&tl={}&dt=t&q={}".format(srcLang, targetLang, text), timeout=4)
+ break
+ except (requests.exceptions.Timeout, requests.exceptions.ConnectionError):
+ pass
+ else:
+ return ""
+
+ if response.status_code != 200:
+ return ""
+ data = response.json()
+ translated_text = ""
+ for item in data[0]:
+ translated_text += item[0]
+ return translated_text
def totranslate(update: Update, context: CallbackContext):
message = update.effective_message
chat = update.effective_chat
- problem_lang_code = []
+ args = context.args
+ reply = message.reply_to_message
text = ""
- for key in LANGUAGES:
- if "-" in key:
- problem_lang_code.append(key)
-
- try:
- if message.reply_to_message:
- args = update.effective_message.text.split(None, 1)
- if message.reply_to_message.text:
- text = message.reply_to_message.text
- elif message.reply_to_message.caption:
- text = message.reply_to_message.caption
-
- try:
- source_lang = args[1].split(None, 1)[0]
- except (IndexError, AttributeError):
- source_lang = "en"
-
- else:
- args = update.effective_message.text.split(None, 2)
- text = args[2]
- source_lang = args[1]
-
- if source_lang.count("-") == 2:
- for lang in problem_lang_code:
- if lang in source_lang:
- if source_lang.startswith(lang):
- dest_lang = source_lang.rsplit("-", 1)[1]
- source_lang = source_lang.rsplit("-", 1)[0]
- else:
- dest_lang = source_lang.split("-", 1)[1]
- source_lang = source_lang.split("-", 1)[0]
- elif source_lang.count("-") == 1:
- for lang in problem_lang_code:
- if lang in source_lang:
- dest_lang = source_lang
- source_lang = None
- break
- if dest_lang is None:
- dest_lang = source_lang.split("-")[1]
- source_lang = source_lang.split("-")[0]
- else:
- dest_lang = source_lang
- source_lang = None
-
- exclude_list = UNICODE_EMOJI.keys()
- for emoji in exclude_list:
- if emoji in text:
- text = text.replace(emoji, "")
-
- trl = google_translator()
- if source_lang is None:
- detection = trl.detect(text)
- trans_str = trl.translate(text, lang_tgt=dest_lang)
- delmsg = message.reply_text(
- f"Translated from `{detection[0]}` to `{dest_lang}`:\n`{trans_str}`",
- parse_mode=ParseMode.MARKDOWN,
- )
- else:
- trans_str = trl.translate(text, lang_tgt=dest_lang, lang_src=source_lang)
- delmsg = message.reply_text(
- f"Translated from `{source_lang}` to `{dest_lang}`:\n`{trans_str}`",
- parse_mode=ParseMode.MARKDOWN,
- )
-
- deletion(update, context, delmsg)
-
- except IndexError:
- delmsg = update.effective_message.reply_text(
- "Reply to messages or write messages from other languages āāfor translating into the intended language\n\n"
+ if reply:
+ if reply.document or reply.video or reply.animation or reply.photo:
+ if reply.caption:
+ text = reply.caption
+ elif reply.text:
+ text = reply.text
+
+ if not text:
+ delmsg = message.reply_text(
+ "Reply to messages from other languages for translating into the intended language\n\n"
"Example: `/tr en-ml` to translate from English to Malayalam\n"
"Or use: `/tr ml` for automatic detection and translating it into Malayalam.\n"
"See [List of Language Codes](t.me/OnePunchSupport/12823) for a list of language codes.",
@@ -90,11 +164,57 @@ def totranslate(update: Update, context: CallbackContext):
disable_web_page_preview=True,
)
deletion(update, context, delmsg)
- except ValueError:
- delmsg = update.effective_message.reply_text("The intended language is not found!")
- deletion(update, context, delmsg)
+ return
+ if not args:
+ srcLang = "auto"
+ targetLang = "en" # Default to english if no arguments were given
+ elif "-" in args[0]:
+ try:
+ srcLang = args[0].split('-')[0]
+ except:
+ srcLang = "auto"
+ try:
+ targetLang = args[0].split('-')[1]
+ except:
+ message.reply_text("Well damn, that does not look like a target language")
+ return
else:
+ try:
+ srcLang = args[0]
+ targetLang = args[1]
+ except:
+ targetLang = args[0]
+ srcLang = "auto"
+
+ # Convert them to lowercase so we don't get issues
+ srcLang = srcLang.lower()
+ targetLang = targetLang.lower()
+
+
+ # If target language is 'english', set it to 'en'
+ for key, value in languages.items():
+ if value.lower() == targetLang:
+ targetLang = key
+ break
+
+ # If source language is 'english', set it to 'en'
+ for key, value in languages.items():
+ if value.lower() == srcLang:
+ srcLang = key
+ break
+
+ # Make sure language actually exists
+ if targetLang not in languages:
+ message.reply_text("That does not look like a valid language.")
+ return
+
+ reply_msg = message.reply_text("Translating to {}...".format(languages[targetLang]))
+ translated = tr(text, srcLang, targetLang)
+ if not translated:
+ reply_msg.edit_text("Failed to translate to {}. Try again in a few seconds or try another target language!".format(languages[targetLang]))
return
+ reply_msg.edit_text("Translated to {}:\n\n".format(languages[targetLang]) + translated)
+ return
def deletion(update: Update, context: CallbackContext, delmsg):
diff --git a/AstrakoBot/modules/helper_funcs/admin_status.py b/AstrakoBot/modules/helper_funcs/admin_status.py
new file mode 100644
index 0000000000..1d9cdf2514
--- /dev/null
+++ b/AstrakoBot/modules/helper_funcs/admin_status.py
@@ -0,0 +1,102 @@
+from threading import RLock
+
+from cachetools import TTLCache
+
+from telegram import Chat, ChatMember, TelegramError, Update
+from telegram.ext import CallbackContext, ChatMemberHandler
+from telegram.error import Unauthorized
+
+from AstrakoBot import SUDO_USERS, dispatcher
+
+BOT_ADMIN_CACHE = TTLCache(maxsize = 512, ttl = 60 * 30)
+USER_ADMIN_CACHE = TTLCache(maxsize = 512, ttl = 60 * 30)
+RLOCK = RLock()
+
+
+def get_bot_member(chat_id: int) -> ChatMember:
+ try:
+ return BOT_ADMIN_CACHE[chat_id]
+ except KeyError:
+ try:
+ mem = dispatcher.bot.getChatMember(chat_id, dispatcher.bot.id)
+ BOT_ADMIN_CACHE[chat_id] = mem
+ return mem
+ except:
+ bot_user = dispatcher.bot.get_me()
+ ghost = ChatMember(
+ user=bot_user,
+ status='member',
+ can_be_edited=False,
+ is_anonymous=False,
+ can_manage_chat=False,
+ can_delete_messages=False,
+ can_manage_video_chats=False,
+ can_restrict_members=False,
+ can_promote_members=False,
+ can_change_info=False,
+ can_invite_users=False,
+ can_post_messages=False,
+ can_edit_messages=False,
+ can_pin_messages=False,
+ can_manage_topics=False,
+ can_send_messages=False,
+ )
+ return ghost
+
+
+def user_is_admin(chat: Chat, user_id: int) -> bool:
+ if chat.type == "private" or user_id in SUDO_USERS:
+ return True
+
+ member: ChatMember = get_mem_from_cache(user_id, chat.id)
+
+ if not member: # not in cache so not an admin
+ return False
+
+ return member.status in ["administrator", "creator"] # check if user is admin
+
+
+def get_mem_from_cache(user_id: int, chat_id: int) -> ChatMember:
+ with RLOCK:
+ try:
+ for i in USER_ADMIN_CACHE[chat_id]:
+ if i.user.id == user_id:
+ return i
+
+ except KeyError:
+ try:
+ admins = dispatcher.bot.getChatAdministrators(chat_id)
+ except Unauthorized:
+ return None
+ USER_ADMIN_CACHE[chat_id] = admins
+ for i in admins:
+ if i.user.id == user_id:
+ return i
+
+
+def admincacheupdates(update: Update, _: CallbackContext):
+ try:
+ oldstat = update.chat_member.old_chat_member.status
+ newstat = update.chat_member.new_chat_member.status
+ except AttributeError:
+ return
+ if (
+ oldstat == "administrator"
+ and newstat != "administrator"
+ or oldstat != "administrator"
+ and newstat == "administrator"
+ ):
+
+ USER_ADMIN_CACHE[update.effective_chat.id] = update.effective_chat.get_administrators()
+
+
+def botstatchanged(update: Update, _: CallbackContext):
+ if update.effective_chat.type != "private":
+ try:
+ BOT_ADMIN_CACHE[update.effective_chat.id] = update.effective_chat.get_member(dispatcher.bot.id)
+ except TelegramError:
+ pass
+
+
+dispatcher.add_handler(ChatMemberHandler(botstatchanged, ChatMemberHandler.MY_CHAT_MEMBER, run_async=True), group=-20)
+dispatcher.add_handler(ChatMemberHandler(admincacheupdates, ChatMemberHandler.CHAT_MEMBER, run_async=True), group=-21)
diff --git a/AstrakoBot/modules/helper_funcs/chat_status.py b/AstrakoBot/modules/helper_funcs/chat_status.py
index 288b4dd56d..1d2021b454 100644
--- a/AstrakoBot/modules/helper_funcs/chat_status.py
+++ b/AstrakoBot/modules/helper_funcs/chat_status.py
@@ -15,6 +15,8 @@
from telegram import Chat, ChatMember, ParseMode, Update
from telegram.ext import CallbackContext
+from telegram.error import Unauthorized
+from AstrakoBot.modules.helper_funcs.admin_status import get_bot_member, user_is_admin
# stores admemes in memory for 10 min.
ADMIN_CACHE = TTLCache(maxsize=512, ttl=60 * 10, timer=perf_counter)
@@ -33,45 +35,18 @@ def is_sudo_plus(chat: Chat, user_id: int, member: ChatMember = None) -> bool:
return user_id in SUDO_USERS or user_id in DEV_USERS
-def is_user_admin(chat: Chat, user_id: int, member: ChatMember = None) -> bool:
- if (
- chat.type == "private"
- or user_id in SUDO_USERS
- or user_id in DEV_USERS
- or chat.all_members_are_administrators
- or user_id in [1087968824]
- ): # Count telegram and Group Anonymous as admin
- return True
- if not member:
- with THREAD_LOCK:
- # try to fetch from cache first.
- try:
- return user_id in ADMIN_CACHE[chat.id]
- except KeyError:
- # keyerror happend means cache is deleted,
- # so query bot api again and return user status
- # while saving it in cache for future useage...
- chat_admins = dispatcher.bot.getChatAdministrators(chat.id)
- admin_list = [x.user.id for x in chat_admins]
- ADMIN_CACHE[chat.id] = admin_list
-
- return user_id in admin_list
- else:
- return member.status in ("administrator", "creator")
-
-
def is_bot_admin(chat: Chat, bot_id: int, bot_member: ChatMember = None) -> bool:
if chat.type == "private" or chat.all_members_are_administrators:
return True
if not bot_member:
- bot_member = chat.get_member(bot_id)
+ bot_member = get_bot_member(chat.id)
return bot_member.status in ("administrator", "creator")
def can_delete(chat: Chat, bot_id: int) -> bool:
- return chat.get_member(bot_id).can_delete_messages
+ return get_bot_member(chat.id).can_delete_messages
def is_user_ban_protected(chat: Chat, user_id: int, member: ChatMember = None) -> bool:
@@ -135,15 +110,22 @@ def is_dev_plus_func(update: Update, context: CallbackContext, *args, **kwargs):
update.effective_message.delete()
except:
pass
- else:
- update.effective_message.reply_text(
- "This is a developer restricted command."
- " You do not have permissions to run this."
- )
return is_dev_plus_func
+def sudo_plus_silent(func):
+ @wraps(func)
+ def is_sudo_plus_func(update: Update, context: CallbackContext, *args, **kwargs):
+ bot = context.bot
+ user = update.effective_user
+ chat = update.effective_chat
+
+ if user and is_sudo_plus(chat, user.id):
+ return func(update, context, *args, **kwargs)
+
+ return is_sudo_plus_func
+
def sudo_plus(func):
@wraps(func)
def is_sudo_plus_func(update: Update, context: CallbackContext, *args, **kwargs):
@@ -160,10 +142,6 @@ def is_sudo_plus_func(update: Update, context: CallbackContext, *args, **kwargs)
update.effective_message.delete()
except:
pass
- else:
- update.effective_message.reply_text(
- "Who dis non-admin telling me what to do? You want a punch?"
- )
return is_sudo_plus_func
@@ -212,7 +190,7 @@ def is_admin(update: Update, context: CallbackContext, *args, **kwargs):
user = update.effective_user
chat = update.effective_chat
- if user and is_user_admin(chat, user.id):
+ if user and user_is_admin(chat, user.id):
return func(update, context, *args, **kwargs)
elif not user:
pass
@@ -238,7 +216,7 @@ def is_not_admin_no_reply(
user = update.effective_user
chat = update.effective_chat
- if user and is_user_admin(chat, user.id):
+ if user and user_is_admin(chat, user.id):
return func(update, context, *args, **kwargs)
elif not user:
pass
@@ -258,7 +236,7 @@ def is_not_admin(update: Update, context: CallbackContext, *args, **kwargs):
user = update.effective_user
chat = update.effective_chat
- if user and not is_user_admin(chat, user.id):
+ if user and not user_is_admin(chat, user.id):
return func(update, context, *args, **kwargs)
elif not user:
pass
@@ -323,7 +301,7 @@ def pin_rights(update: Update, context: CallbackContext, *args, **kwargs):
else:
cant_pin = f"I can't pin messages in {update_chat_title}!\nMake sure I'm admin and can pin messages there."
- if chat.get_member(bot.id).can_pin_messages:
+ if get_bot_member(chat.id).can_pin_messages:
return func(update, context, *args, **kwargs)
else:
update.effective_message.reply_text(cant_pin, parse_mode=ParseMode.HTML)
@@ -347,7 +325,7 @@ def promote_rights(update: Update, context: CallbackContext, *args, **kwargs):
f"Make sure I'm admin there and can appoint new admins."
)
- if chat.get_member(bot.id).can_promote_members:
+ if get_bot_member(chat.id).can_promote_members:
return func(update, context, *args, **kwargs)
else:
update.effective_message.reply_text(cant_promote, parse_mode=ParseMode.HTML)
@@ -368,7 +346,7 @@ def restrict_rights(update: Update, context: CallbackContext, *args, **kwargs):
else:
cant_restrict = f"I can't restrict people in {update_chat_title}!\nMake sure I'm admin there and can restrict users."
- if chat.get_member(bot.id).can_restrict_members:
+ if get_bot_member(chat.id).can_restrict_members:
return func(update, context, *args, **kwargs)
else:
update.effective_message.reply_text(
@@ -401,6 +379,9 @@ def user_is_banhammer(update: Update, context: CallbackContext, *args, **kwargs)
def connection_status(func):
@wraps(func)
def connected_status(update: Update, context: CallbackContext, *args, **kwargs):
+ if not update.effective_user:
+ return connected_status
+
conn = connected(
context.bot,
update,
diff --git a/AstrakoBot/modules/helper_funcs/extraction.py b/AstrakoBot/modules/helper_funcs/extraction.py
index d8b63fc199..0640b5acdd 100644
--- a/AstrakoBot/modules/helper_funcs/extraction.py
+++ b/AstrakoBot/modules/helper_funcs/extraction.py
@@ -12,6 +12,8 @@ def id_from_reply(message):
return None, None
user_id = prev_message.from_user.id
res = message.text.split(None, 1)
+ if prev_message.sender_chat:
+ user_id = prev_message.sender_chat.id
if len(res) < 2:
return user_id, ""
return user_id, res[1]
diff --git a/AstrakoBot/modules/helper_funcs/filters.py b/AstrakoBot/modules/helper_funcs/filters.py
index 035a8bec01..c892550ea3 100644
--- a/AstrakoBot/modules/helper_funcs/filters.py
+++ b/AstrakoBot/modules/helper_funcs/filters.py
@@ -45,3 +45,11 @@ def filter(self, message: Message):
)
has_text = _HasText()
+
+ class _IsAnonChannel(MessageFilter):
+ def filter(self, message: Message):
+ if (message.from_user and message.from_user.id == 136817688 ):
+ return True
+ return False
+
+ is_anon_channel = _IsAnonChannel()
diff --git a/AstrakoBot/modules/helper_funcs/msg_types.py b/AstrakoBot/modules/helper_funcs/msg_types.py
index 446a53f60e..b8ac4c34fd 100644
--- a/AstrakoBot/modules/helper_funcs/msg_types.py
+++ b/AstrakoBot/modules/helper_funcs/msg_types.py
@@ -137,20 +137,19 @@ def get_welcome_type(msg: Message):
data_type = Types.VIDEO_NOTE
buttons = []
+ argumen = None
# determine what the contents of the filter are - text, image, sticker, etc
- if args:
- if msg.reply_to_message:
- argumen = (
- msg.reply_to_message.caption if msg.reply_to_message.caption else ""
- )
- offset = 0 # offset is no need since target was in reply
- entities = msg.reply_to_message.parse_entities()
- else:
- argumen = args[1]
- offset = len(argumen) - len(
- msg.text
- ) # set correct offset relative to command + notename
- entities = msg.parse_entities()
+ if msg.reply_to_message:
+ argumen = msg.reply_to_message.caption or msg.reply_to_message.text or ""
+ offset = 0 # offset is no need since target was in reply
+ entities = msg.reply_to_message.parse_entities()
+ elif args and len(args) > 1:
+ argumen = args[1]
+ offset = len(argumen) - len(
+ msg.text
+ ) # set correct offset relative to command + notename
+ entities = msg.parse_entities()
+ if argumen:
text, buttons = button_markdown_parser(
argumen, entities=entities, offset=offset
)
diff --git a/AstrakoBot/modules/helper_funcs/string_handling.py b/AstrakoBot/modules/helper_funcs/string_handling.py
index 4164c7d241..2c6aa14b10 100644
--- a/AstrakoBot/modules/helper_funcs/string_handling.py
+++ b/AstrakoBot/modules/helper_funcs/string_handling.py
@@ -261,24 +261,37 @@ def extract_time(message, time_val):
return ""
if unit == "m":
- bantime = int(time.time() + int(time_num) * 60)
+ bantime = int(time.time()) + int(time_num) * 60
elif unit == "h":
- bantime = int(time.time() + int(time_num) * 60 * 60)
+ bantime = int(time.time()) + int(time_num) * 60 * 60
elif unit == "d":
- bantime = int(time.time() + int(time_num) * 24 * 60 * 60)
+ bantime = int(time.time()) + int(time_num) * 24 * 60 * 60
else:
# how even...?
return ""
return bantime
else:
message.reply_text(
- "Invalid time type specified. Expected m,h, or d, got: {}".format(
+ "Invalid time type specified. Expected m, h, or d, got: {}".format(
time_val[-1]
)
)
return ""
+def parse_to_seconds(time_str):
+ if time_str.isdigit():
+ return int(time_str) or None
+
+ match = re.match(r"\s*([\d.]+)\s*([a-z]*)\s*", time_str, re.IGNORECASE)
+ if len(time_str) > 50 or not match:
+ return None
+
+ value, unit = float(match[1]), match[2].lower()
+ multipliers = {'d': 86400, 'h': 3600, 'm': 60, 's': 1}
+ return int(value * multipliers.get(unit[:1], 0)) or None
+
+
def markdown_to_html(text):
text = text.replace("*", "**")
text = text.replace("`", "```")
diff --git a/AstrakoBot/modules/linux.py b/AstrakoBot/modules/linux.py
new file mode 100644
index 0000000000..340fea7c16
--- /dev/null
+++ b/AstrakoBot/modules/linux.py
@@ -0,0 +1,77 @@
+import requests
+from AstrakoBot import dispatcher
+from telegram import Update, ParseMode
+from telegram.ext import CallbackContext, CommandHandler, run_async
+from AstrakoBot.modules.sql.clear_cmd_sql import get_clearcmd
+from AstrakoBot.modules.helper_funcs.misc import delete
+from datetime import datetime
+import re
+
+def linux_kernels(update: Update, context: CallbackContext):
+ chat = update.effective_chat
+ headers = {"User-Agent": "Mozilla/5.0 (X11; Linux x86_64; rv:10.0) Gecko/20100101 Firefox/10.0"}
+
+ try:
+ response = requests.get("https://www.kernel.org/releases.json", headers=headers)
+ response.raise_for_status()
+ data = response.json()
+ except Exception as e:
+ update.effective_message.reply_text(f"Error fetching kernel data: {str(e)}")
+ return
+
+ releases = data.get("releases", [])
+ if not releases:
+ update.effective_message.reply_text("No kernel releases found.")
+ return
+
+ message = "Linux Kernel Versions\n\n"
+ for release in releases[:10]:
+ version = release.get("version", "Unknown")
+ moniker = release.get("moniker", "").lower()
+ timestamp = release.get("released", {}).get("timestamp", 0)
+ source_url = release.get("gitweb", "#")
+
+ category = "MAINLINE"
+ if release.get("iseol"):
+ category = "EOL"
+ elif "longterm" in moniker:
+ category = "LTS"
+ elif "stable" in moniker:
+ category = "STABLE"
+ elif "linux-next" in moniker:
+ category = "NEXT"
+
+ message += (
+ f"ā¢ {version}\n"
+ f" ā {category} "
+ f"({datetime.fromtimestamp(timestamp).strftime('%Y-%m-%d')})\n\n"
+ )
+
+ message += "Source: kernel.org"
+
+ try:
+ delmsg = update.effective_message.reply_text(
+ message,
+ parse_mode=ParseMode.HTML,
+ disable_web_page_preview=True
+ )
+ except Exception as e:
+ update.effective_message.reply_text(f"Error formatting message: {str(e)}")
+ return
+
+ cleartime = get_clearcmd(chat.id, "kernels")
+ if cleartime:
+ context.dispatcher.run_async(delete, delmsg, cleartime.time)
+
+__help__ = """
+*Available commands:*\n
+*Linux Kernel:*
+ā¢ `/kernels`: fetches linux kernels information\n
+"""
+
+KERNELS_HANDLER = CommandHandler("kernels", linux_kernels, run_async=True)
+dispatcher.add_handler(KERNELS_HANDLER)
+
+__mod_name__ = "Linux"
+__command_list__ = ["kernels"]
+__handlers__ = [KERNELS_HANDLER]
diff --git a/AstrakoBot/modules/locks.py b/AstrakoBot/modules/locks.py
index 17a9117f38..2d8c6cfebc 100644
--- a/AstrakoBot/modules/locks.py
+++ b/AstrakoBot/modules/locks.py
@@ -1,5 +1,6 @@
import html
+import telegram.ext as tg
from telegram import Message, Chat, ParseMode, MessageEntity, Update
from telegram import TelegramError, ChatPermissions
from telegram.error import BadRequest
@@ -10,11 +11,11 @@
from alphabet_detector import AlphabetDetector
import AstrakoBot.modules.sql.locks_sql as sql
+from AstrakoBot.modules.helper_funcs.admin_status import user_is_admin
from AstrakoBot import dispatcher, SUDO_USERS, LOGGER
from AstrakoBot.modules.disable import DisableAbleCommandHandler
from AstrakoBot.modules.helper_funcs.chat_status import (
can_delete,
- is_user_admin,
user_not_admin,
is_bot_admin,
user_admin,
@@ -23,6 +24,7 @@
from AstrakoBot.modules.connection import connected
from AstrakoBot.modules.sql.approve_sql import is_approved
from AstrakoBot.modules.helper_funcs.alternate import send_message, typing_action
+from AstrakoBot.modules.helper_funcs.filters import CustomFilters
ad = AlphabetDetector()
@@ -40,6 +42,7 @@
"game": Filters.game,
"location": Filters.location,
"egame": Filters.dice,
+ "anonchannel": CustomFilters.is_anon_channel,
"rtl": "rtl",
"button": "button",
"inline": "inline",
@@ -93,6 +96,25 @@
REST_GROUP = 2
+class CustomCommandHandler(tg.CommandHandler):
+ def __init__(self, command, callback, **kwargs):
+ super().__init__(command, callback, **kwargs)
+
+ def check_update(self, update):
+ if super().check_update(update) and not (
+ sql.is_restr_locked(update.effective_chat.id, 'messages') and not user_is_admin(update.effective_chat,
+ update.effective_user.id)):
+ args = update.effective_message.text.split()[1:]
+ filter_result = self.filters(update)
+ if filter_result:
+ return args, filter_result
+ else:
+ return False
+
+
+CommandHandler = CustomCommandHandler
+
+
# NOT ASYNC
def restr_members(
bot, chat_id, members, messages=False, media=False, other=False, previews=False
@@ -100,15 +122,18 @@ def restr_members(
for mem in members:
if mem.user in SUDO_USERS:
pass
+ elif mem.user == 777000 or mem.user == 1087968824:
+ pass
try:
bot.restrict_chat_member(
chat_id,
mem.user,
+ permissions=ChatPermissions(
can_send_messages=messages,
can_send_media_messages=media,
can_send_other_messages=other,
can_add_web_page_previews=previews,
- )
+ ))
except TelegramError:
pass
@@ -218,6 +243,18 @@ def lock(update: Update, context: CallbackContext) -> str:
),
)
+ context.bot.restrict_chat_member(chat.id, int(777000), permissions=ChatPermissions(
+ can_send_messages=True,
+ can_send_media_messages=True,
+ can_send_other_messages=True,
+ can_add_web_page_previews=True))
+
+ context.bot.restrict_chat_member(chat.id, int(1087968824), permissions=ChatPermissions(
+ can_send_messages=True,
+ can_send_media_messages=True,
+ can_send_other_messages=True,
+ can_add_web_page_previews=True))
+
send_message(update.effective_message, text, parse_mode="markdown")
return (
"{}:"
@@ -255,7 +292,7 @@ def unlock(update: Update, context: CallbackContext) -> str:
chat = update.effective_chat
user = update.effective_user
message = update.effective_message
- if is_user_admin(chat, message.from_user.id):
+ if user_is_admin(chat, message.from_user.id):
if len(args) >= 1:
ltype = args[0].lower()
if ltype in LOCK_TYPES:
@@ -426,7 +463,7 @@ def del_lockables(update: Update, context: CallbackContext):
)
return
- chat.kick_member(new_mem.id)
+ chat.ban_member(new_mem.id)
send_message(
update.effective_message,
"Only admins are allowed to add bots in this chat! Get outta here.",
@@ -469,6 +506,7 @@ def build_lock_message(chat_id):
locklist.append("button = `{}`".format(locks.button))
locklist.append("egame = `{}`".format(locks.egame))
locklist.append("inline = `{}`".format(locks.inline))
+ locklist.append("anonchannel = `{}`".format(locks.anonchannel))
permissions = dispatcher.bot.get_chat(chat_id).permissions
permslist.append("messages = `{}`".format(permissions.can_send_messages))
permslist.append("media = `{}`".format(permissions.can_send_media_messages))
diff --git a/AstrakoBot/modules/log_channel.py b/AstrakoBot/modules/log_channel.py
index 28a0b28ffb..4ff68871a1 100644
--- a/AstrakoBot/modules/log_channel.py
+++ b/AstrakoBot/modules/log_channel.py
@@ -39,9 +39,16 @@ def log_action(
result += "\nEvent Stamp: {}".format(
datetime.utcnow().strftime(datetime_fmt)
)
+ try:
+ if message and chat.type == chat.SUPERGROUP:
+ if chat.username:
+ result += f'\nLink: click here'
+ else:
+ cid = str(chat.id).replace("-100", '')
+ result += f'\nLink: click here'
+ except AttributeError:
+ result += '\nLink: No link for manual actions.'
- if message.chat.type == chat.SUPERGROUP and message.chat.username:
- result += f'\nLink: click here'
log_chat = sql.get_chat_log_channel(chat.id)
if log_chat:
send_log(context, log_chat, chat.id, result)
@@ -109,13 +116,16 @@ def logging(update: Update, context: CallbackContext):
log_channel = sql.get_chat_log_channel(chat.id)
if log_channel:
- log_channel_info = bot.get_chat(log_channel)
- message.reply_text(
- f"This group has all it's logs sent to:"
- f" {escape_markdown(log_channel_info.title)} (`{log_channel}`)",
- parse_mode=ParseMode.MARKDOWN,
- )
-
+ try:
+ log_channel_info = bot.get_chat(log_channel)
+ message.reply_text(
+ f"This group has all it's logs sent to:"
+ f" {escape_markdown(log_channel_info.title)} (`{log_channel}`)",
+ parse_mode=ParseMode.MARKDOWN,
+ )
+ except Unauthorized:
+ sql.stop_chat_logging(chat.id)
+ message.reply_text("No log channel has been set for this group!")
else:
message.reply_text("No log channel has been set for this group!")
diff --git a/AstrakoBot/modules/media.py b/AstrakoBot/modules/media.py
index c8be181dc1..32dc955ba9 100644
--- a/AstrakoBot/modules/media.py
+++ b/AstrakoBot/modules/media.py
@@ -14,7 +14,7 @@
*Text to speech:*
ā¢ `/tts āMute Event\n"
- f" ā¢ User: {mention_html(member.user.id, html.escape(member.user.first_name))}\n"
- f" ā¢ Time: no expiration date"
- )
- if reason:
- reply += f"\n ā¢ Reason: {html.escape(reason)}"
- bot.sendMessage(chat.id, reply, parse_mode=ParseMode.HTML)
+ if not silent:
+ reply = (
+ f"āMute Event\n"
+ f" ā¢ User: {mention_html(member.user.id, html.escape(member.user.first_name))}\n"
+ f" ā¢ Time: no expiration date"
+ )
+ if reason:
+ reply += f"\n ā¢ Reason: {html.escape(reason)}"
+ bot.sendMessage(chat.id, reply, parse_mode=ParseMode.HTML)
+ else:
+ message.delete()
return log
else:
- message.reply_text("This user is already muted!")
+ if not silent:
+ message.reply_text("This user is already muted!")
+ else:
+ message.delete()
return ""
@@ -103,6 +121,8 @@ def mute(update: Update, context: CallbackContext) -> str:
@connection_status
@bot_admin
@user_admin
+@user_can_ban
+@can_restrict
@loggable
def unmute(update: Update, context: CallbackContext) -> str:
bot, args = context.bot, context.args
@@ -110,23 +130,33 @@ def unmute(update: Update, context: CallbackContext) -> str:
user = update.effective_user
message = update.effective_message
+ silent = False
+ if message.text.startswith("/s") or message.text.startswith("!s"):
+ silent = True
+ if not can_delete(chat, context.bot.id):
+ return ""
+
user_id = extract_user(message, args)
if not user_id:
- message.reply_text(
- "You'll need to either give me a username to unmute, or reply to someone to be unmuted."
- )
+ if silent:
+ message.delete()
+ else:
+ message.reply_text(
+ "You'll need to either give me a username to unmute, or reply to someone to be unmuted."
+ )
return ""
member = chat.get_member(int(user_id))
if member.status != "kicked" and member.status != "left":
if (
- member.can_send_messages
- and member.can_send_media_messages
- and member.can_send_other_messages
- and member.can_add_web_page_previews
+ member.can_send_messages is not False
+ and member.can_send_media_messages is not False
+ and member.can_send_other_messages is not False
+ and member.can_add_web_page_previews is not False
):
- message.reply_text("This user already has the right to speak.")
+ if not silent:
+ message.reply_text("This user already has the right to speak.")
else:
chat_permissions = ChatPermissions(
can_send_messages=True,
@@ -142,11 +172,14 @@ def unmute(update: Update, context: CallbackContext) -> str:
bot.restrict_chat_member(chat.id, int(user_id), chat_permissions)
except BadRequest:
pass
- bot.sendMessage(
- chat.id,
- f"I shall allow {html.escape(member.user.first_name)} to text!",
- parse_mode=ParseMode.HTML,
- )
+ if not silent:
+ bot.sendMessage(
+ chat.id,
+ f"I shall allow {html.escape(member.user.first_name)} to text!",
+ parse_mode=ParseMode.HTML,
+ )
+ else:
+ message.delete()
return (
f"{html.escape(chat.title)}:\n"
f"#UNMUTE\n"
@@ -154,11 +187,14 @@ def unmute(update: Update, context: CallbackContext) -> str:
f"User: {mention_html(member.user.id, member.user.first_name)}"
)
else:
- message.reply_text(
- "This user isn't even in the chat, unmuting them won't make them talk more than they "
- "already do!"
- )
+ if not silent:
+ message.reply_text(
+ "This user isn't even in the chat, unmuting them won't make them talk more than they "
+ "already do!"
+ )
+ if silent:
+ message.delete()
return ""
@@ -166,6 +202,7 @@ def unmute(update: Update, context: CallbackContext) -> str:
@bot_admin
@can_restrict
@user_admin
+@user_can_ban
@loggable
def temp_mute(update: Update, context: CallbackContext) -> str:
bot, args = context.bot, context.args
@@ -176,6 +213,12 @@ def temp_mute(update: Update, context: CallbackContext) -> str:
user_id, reason = extract_user_and_text(message, args)
reply = check_user(user_id, bot, chat)
+ silent = False
+ if message.text.startswith("/s") or message.text.startswith("!s"):
+ silent = True
+ if not can_delete(chat, context.bot.id):
+ return ""
+
if reply:
message.reply_text(reply)
return ""
@@ -183,7 +226,10 @@ def temp_mute(update: Update, context: CallbackContext) -> str:
member = chat.get_member(user_id)
if not reason:
- message.reply_text("You haven't specified a time to mute this user for!")
+ if not silent:
+ message.reply_text("You haven't specified a time to mute this user for!")
+ else:
+ message.delete()
return ""
split_reason = reason.split(None, 1)
@@ -210,11 +256,11 @@ def temp_mute(update: Update, context: CallbackContext) -> str:
log += f"\nReason: {reason}"
try:
- if member.can_send_messages is None or member.can_send_messages:
- chat_permissions = ChatPermissions(can_send_messages=False)
- bot.restrict_chat_member(
- chat.id, user_id, chat_permissions, until_date=mutetime
- )
+ chat_permissions = ChatPermissions(can_send_messages=False)
+ bot.restrict_chat_member(
+ chat.id, user_id, chat_permissions, until_date=mutetime
+ )
+ if not silent:
reply = (
f"āMute Event\n"
f" ā¢ User: {mention_html(member.user.id, html.escape(member.user.first_name))}\n"
@@ -223,14 +269,17 @@ def temp_mute(update: Update, context: CallbackContext) -> str:
if reason:
reply += f"\n ā¢ Reason: {html.escape(reason)}"
bot.sendMessage(chat.id, reply, parse_mode=ParseMode.HTML)
- return log
else:
- message.reply_text("This user is already muted.")
+ message.delete()
+ return log
except BadRequest as excp:
if excp.message == "Reply message not found":
# Do not reply
- message.reply_text(f"Muted for {time_val}!", quote=False)
+ if not silent:
+ message.reply_text(f"Muted for {time_val}!", quote=False)
+ else:
+ message.delete()
return log
else:
LOGGER.warning(update)
@@ -241,7 +290,10 @@ def temp_mute(update: Update, context: CallbackContext) -> str:
chat.id,
excp.message,
)
- message.reply_text("Well damn, I can't mute that user.")
+ if not silent:
+ message.reply_text("Well damn, I can't mute that user.")
+ else:
+ message.delete()
return ""
@@ -253,9 +305,9 @@ def temp_mute(update: Update, context: CallbackContext) -> str:
ā¢ `/unmute {user.id}.",
- parse_mode=ParseMode.HTML,
- )
+ try:
+ user = bot.get_chat(user_id)
+ msg.reply_text(
+ f"{html.escape(user.first_name)}'s id is {user.id}.",
+ parse_mode=ParseMode.HTML,
+ )
+ except:
+ msg.reply_text(
+ f"Their id is {user_id}.",
+ parse_mode=ParseMode.HTML,
+ )
else:
@@ -82,37 +94,130 @@ def get_id(update: Update, context: CallbackContext):
events.NewMessage(pattern="/ginfo ", from_users=(SUDO_USERS or []) + (SUPPORT_USERS or []))
)
async def group_info(event) -> None:
- chat = event.text.split(" ", 1)[1]
+ target_entity = None
+ entity_id_str = None
+
+ if event.is_reply:
+ replied_msg = await event.get_reply_message()
+ if replied_msg and replied_msg.sender_id:
+ target_entity = replied_msg.sender_id
+ entity_id_str = str(target_entity)
+ else:
+ await event.reply("Could not identify the user from the replied message.")
+ return
+ else:
+ parts = event.text.split(" ", 1)
+ if len(parts) > 1:
+ entity_id_str = parts[1].strip()
+ if entity_id_str.startswith('@'):
+ target_entity = entity_id_str
+ else:
+ try:
+ target_entity = int(entity_id_str)
+ except ValueError:
+ await event.reply("Invalid ID or username format.")
+ return
+ else:
+ target_entity = event.chat_id
+ entity_id_str = str(target_entity)
+
+ if target_entity is None:
+ await event.reply("Could not determine the target entity.")
+ return
+
try:
- entity = await event.client.get_entity(chat)
- totallist = await event.client.get_participants(
- entity, filter=ChannelParticipantsAdmins
- )
- ch_full = await event.client(GetFullChannelRequest(channel=entity))
- except:
+ entity = await event.client.get_entity(target_entity)
+ except (ValueError, PeerIdInvalidError, ChannelInvalidError, ChannelPrivateError) as e:
await event.reply(
- "Can't for some reason, maybe it is a private one or that I am banned there."
+ f"Could not find or access the specified chat/channel (`{entity_id_str}`). "
+ "It might be invalid, private, or I might lack permissions."
)
return
- msg = f"**ID**: `{entity.id}`"
- msg += f"\n**Title**: `{entity.title}`"
- msg += f"\n**Datacenter**: `{entity.photo.dc_id}`"
- msg += f"\n**Video PFP**: `{entity.photo.has_video}`"
- msg += f"\n**Supergroup**: `{entity.megagroup}`"
- msg += f"\n**Restricted**: `{entity.restricted}`"
- msg += f"\n**Scam**: `{entity.scam}`"
- msg += f"\n**Slowmode**: `{entity.slowmode_enabled}`"
- if entity.username:
- msg += f"\n**Username**: {entity.username}"
- msg += "\n\n**Member Stats:**"
- msg += f"\n`Admins:` `{len(totallist)}`"
- msg += f"\n`Users`: `{totallist.total}`"
- msg += "\n\n**Admins List:**"
- for x in totallist:
- msg += f"\nā¢ [{x.id}](tg://user?id={x.id})"
- msg += f"\n\n**Description**:\n`{ch_full.full_chat.about}`"
- await event.reply(msg)
+ except Exception as e:
+ await event.reply(f"An unexpected error occurred while fetching info for `{entity_id_str}`.")
+ return
+ msg = f"**Info for:** `{entity_id_str}`\n"
+ msg += f"**Type:** `{type(entity).__name__}`\n"
+ msg += f"**ID:** `{entity.id}`\n"
+
+ if isinstance(entity, (types.Chat, types.Channel)):
+ msg += f"**Title:** `{entity.title}`\n"
+ if hasattr(entity, 'username') and entity.username:
+ msg += f"**Username:** @{entity.username}\n"
+ else:
+ msg += f"**Username:** `None`\n"
+
+ if hasattr(entity.photo, 'dc_id'):
+ msg += f"**Photo DC:** `{entity.photo.dc_id}`\n"
+ if hasattr(entity.photo, 'has_video'):
+ msg += f"**Video PFP:** `{entity.photo.has_video}`\n"
+
+ msg += f"**Scam:** `{getattr(entity, 'scam', 'N/A')}`\n"
+ msg += f"**Restricted:** `{getattr(entity, 'restricted', 'N/A')}`\n"
+ if getattr(entity, 'restriction_reason', None):
+ msg += f"**Restriction Reason:** `{entity.restriction_reason}`\n"
+
+ if isinstance(entity, types.Channel):
+ msg += f"**Supergroup:** `{entity.megagroup}`\n"
+ msg += f"**Broadcast Channel:** `{entity.broadcast}`\n"
+ msg += f"**Verified:** `{entity.verified}`\n"
+ msg += f"**Gigagroup:** `{getattr(entity, 'gigagroup', 'N/A')}`\n"
+ msg += f"**Slowmode Enabled:** `{entity.slowmode_enabled}`\n"
+
+ full_chat_info = None
+ admin_list = []
+ participant_count = "N/A"
+ admin_count = "N/A"
+ about = "N/A"
+
+ try:
+ if isinstance(entity, types.Channel):
+ full_chat_info = await event.client(GetFullChannelRequest(channel=entity))
+ about = full_chat_info.full_chat.about
+ participant_count = getattr(full_chat_info.full_chat, 'participants_count', 'N/A')
+ elif isinstance(entity, types.Chat):
+ full_chat_info = await event.client(GetFullChatRequest(chat_id=entity.id))
+ about = getattr(full_chat_info.full_chat, 'about', 'N/A')
+ if hasattr(full_chat_info, 'users'):
+ participant_count = len(full_chat_info.users)
+
+ try:
+ admins = await event.client.get_participants(
+ entity, filter=ChannelParticipantsAdmins
+ )
+ admin_count = len(admins) if admins else 0 # Handle None case
+ admin_list = [f"ā¢ [{admin.id}](tg://user?id={admin.id})" for admin in admins]
+ except ChatAdminRequiredError:
+ admin_list.append("_(Admin permissions required to list)_")
+ admin_count = "N/A (No Perms)"
+ except UserNotParticipantError:
+ admin_list.append("_(Bot is not in this chat/channel)_")
+ admin_count = "N/A (Not Participant)"
+ except Exception as e:
+ admin_list.append("_(Could not retrieve admin list)_")
+ admin_count = "N/A (Error)"
+
+
+ msg += "\n**Stats:**\n"
+ msg += f"`Participants:` `{participant_count}`\n"
+ msg += f"`Admins:` `{admin_count}`\n"
+
+ if admin_list:
+ msg += "\n**Admins List:**"
+ msg += "\n" + "\n".join(admin_list) # Join list items with newlines
+
+ msg += f"\n\n**Description:**\n`{about}`"
+
+ except (ChatAdminRequiredError, UserNotParticipantError) as e:
+ msg += "\n\n**(Could not retrieve full details like description or participant counts due to permissions or bot not being a participant)**"
+ except Exception as e:
+ msg += "\n\n**(An error occurred while retrieving full details)**"
+
+ else:
+ msg += "\n**(Unsupported entity type)**"
+
+ await event.reply(msg, link_preview=False)
def gifid(update: Update, context: CallbackContext):
msg = update.effective_message
@@ -131,11 +236,27 @@ def info(update: Update, context: CallbackContext):
chat = update.effective_chat
user_id = extract_user(update.effective_message, args)
- if user_id:
+ if user_id and int(user_id) != 777000 and int(user_id) != 1087968824:
user = bot.get_chat(user_id)
+ elif user_id and int(user_id) == 777000:
+ message.reply_text(
+ "This is Telegram. Unless you manually entered this reserved account's ID, it is likely a old broadcast from a linked channel."
+ )
+ return
+
+ elif user_id and int(user_id) == 1087968824:
+ message.reply_text(
+ "This is Group Anonymous Bot. Unless you manually entered this reserved account's ID, it is likely a broadcast from a linked channel or anonymously sent message."
+ )
+ return
+
elif not message.reply_to_message and not args:
- user = message.from_user
+ user = (
+ message.sender_chat
+ if message.sender_chat is not None
+ else message.from_user
+ )
elif not message.reply_to_message and (
not args
@@ -157,128 +278,163 @@ def info(update: Update, context: CallbackContext):
else:
return
+
+ rep = message.reply_text("Appraising...", parse_mode=ParseMode.HTML)
+
+ if hasattr(user, 'type') and user.type != "private":
+ text = (
+ f"Chat Info: "
+ f"\nID: {user.id}"
+ f"\nTitle: {user.title}"
+ )
+ if user.username:
+ text += f"\nUsername: @{html.escape(user.username)}"
+ text += f"\nChat Type: {user.type.capitalize()}"
+
+ if INFOPIC:
+ try:
+ profile = bot.getChat(user.id).photo
+ _file = bot.get_file(profile["big_file_id"])
+ _file.download(f"{user.id}.png")
+
+ delmsg = message.reply_document(
+ document=open(f"{user.id}.png", "rb"),
+ caption=(text),
+ parse_mode=ParseMode.HTML,
+ )
- rep = message.reply_text("Appraising...", parse_mode=ParseMode.HTML)
+ os.remove(f"{user.id}.png")
+ # Incase chat don't have profile pic, send normal text
+ except:
+ delmsg = message.reply_text(
+ text, parse_mode=ParseMode.HTML, disable_web_page_preview=True
+ )
- text = (
- f"User info:\n"
- f"ID: {user.id}\n"
- f"First Name: {html.escape(user.first_name)}"
- )
+ else:
+ delmsg = message.reply_text(
+ text, parse_mode=ParseMode.HTML, disable_web_page_preview=True
+ )
- if user.last_name:
- text += f"\nLast Name: {html.escape(user.last_name)}"
+ else:
+ text = (
+ f"User info:\n"
+ f"ID: {user.id}\n"
+ f"First Name: {mention_html(user.id, user.first_name or 'None')}"
+ )
- if user.username:
- text += f"\nUsername: @{html.escape(user.username)}"
+ if user.last_name:
+ text += f"\nLast Name: {html.escape(user.last_name)}"
- text += f"\nPermalink: {mention_html(user.id, 'link')}"
+ if user.username:
+ text += f"\nUsername: @{html.escape(user.username)}"
- if chat.type != "private" and user_id != bot.id:
- _stext = "\nPresence: {}"
+ text += f"\nPermalink: {mention_html(user.id, 'link')}"
- afk_st = is_afk(user.id)
- if afk_st:
- text += _stext.format("AFK")
- else:
- status = status = bot.get_chat_member(chat.id, user.id).status
- if status:
- if status == "left":
- text += _stext.format("Not here")
- if status == "kicked":
- text += _stext.format("Banned")
- elif status == "member":
- text += _stext.format("Detected")
- elif status in {"administrator", "creator"}:
- text += _stext.format("Admin")
+ if chat.type != "private" and user_id != bot.id:
+ _stext = "\nPresence: {}"
- try:
- spamwtc = sw.get_ban(int(user.id))
- if spamwtc:
- text += "\n\nThis person is Spamwatched!"
- text += f"\nReason: {spamwtc.reason}"
- text += "\nAppeal at @SpamWatchSupport"
- else:
- pass
- except:
- pass # don't crash if api is down somehow...
-
- disaster_level_present = False
-
- if user.id == OWNER_ID:
- text += "\n\nUser level: god"
- disaster_level_present = True
- elif user.id in DEV_USERS:
- text += "\n\nUser level: developer"
- disaster_level_present = True
- elif user.id in SUDO_USERS:
- text += "\n\nUser level: sudo"
- disaster_level_present = True
- elif user.id in SUPPORT_USERS:
- text += "\n\nUser level: support"
- disaster_level_present = True
- elif user.id in WHITELIST_USERS:
- text += "\n\nUser level: whitelist"
- disaster_level_present = True
-
- # if disaster_level_present:
- # text += ' [?]'.format(
- # bot.username)
+ afk_st = is_afk(user.id)
+ if afk_st:
+ text += _stext.format("AFK")
+ else:
+ status = bot.get_chat_member(chat.id, user.id).status
+ if status:
+ if status == "left":
+ text += _stext.format("Not here")
+ if status == "kicked":
+ text += _stext.format("Banned")
+ elif status == "member":
+ text += _stext.format("Detected")
+ elif status in {"administrator", "creator"}:
+ text += _stext.format("Admin")
- try:
- user_member = chat.get_member(user.id)
- if user_member.status == "administrator":
- result = requests.post(
- f"https://api.telegram.org/bot{TOKEN}/getChatMember?chat_id={chat.id}&user_id={user.id}"
- )
- result = result.json()["result"]
- if "custom_title" in result.keys():
- custom_title = result["custom_title"]
- text += f"\n\nTitle:\n{custom_title}"
- except BadRequest:
- pass
-
- for mod in USER_INFO:
try:
- mod_info = mod.__user_info__(user.id).strip()
- except TypeError:
- mod_info = mod.__user_info__(user.id, chat.id).strip()
- if mod_info:
- text += "\n\n" + mod_info
+ spamwtc = sw.get_ban(int(user.id))
+ if spamwtc:
+ text += "\n\nThis person is Spamwatched!"
+ text += f"\nReason: {spamwtc.reason}"
+ text += "\nAppeal at @SpamWatchSupport"
+ else:
+ pass
+ except:
+ pass # don't crash if api is down somehow...
+
+ disaster_level_present = False
+
+ if user.id == OWNER_ID:
+ text += "\n\nUser level: god"
+ disaster_level_present = True
+ elif user.id in DEV_USERS:
+ text += "\n\nUser level: developer"
+ disaster_level_present = True
+ elif user.id in SUDO_USERS:
+ text += "\n\nUser level: sudo"
+ disaster_level_present = True
+ elif user.id in SUPPORT_USERS:
+ text += "\n\nUser level: support"
+ disaster_level_present = True
+ elif user.id in WHITELIST_USERS:
+ text += "\n\nUser level: whitelist"
+ disaster_level_present = True
+
+ # if disaster_level_present:
+ # text += ' [?]'.format(
+ # bot.username)
- if INFOPIC:
try:
- profile = context.bot.get_user_profile_photos(user.id).photos[0][-1]
- _file = bot.get_file(profile["file_id"])
- _file.download(f"{user.id}.png")
+ user_member = chat.get_member(user.id)
+ if user_member.status == "administrator":
+ result = requests.post(
+ f"https://api.telegram.org/bot{TOKEN}/getChatMember?chat_id={chat.id}&user_id={user.id}"
+ )
+ result = result.json()["result"]
+ if "custom_title" in result.keys():
+ custom_title = result["custom_title"]
+ text += f"\n\nTitle:\n{custom_title}"
+ except BadRequest:
+ pass
- delmsg = message.reply_document(
- document=open(f"{user.id}.png", "rb"),
- caption=(text),
- parse_mode=ParseMode.HTML,
- )
+ for mod in USER_INFO:
+ try:
+ mod_info = mod.__user_info__(user.id).strip()
+ except TypeError:
+ mod_info = mod.__user_info__(user.id, chat.id).strip()
+ if mod_info:
+ text += "\n\n" + mod_info
+
+ text += "\n\n" + biome(user.id)
+
+ if INFOPIC:
+ try:
+ profile = context.bot.get_user_profile_photos(user.id).photos[0][-1]
+ _file = bot.get_file(profile["file_id"])
+ _file.download(f"{user.id}.png")
+
+ delmsg = message.reply_document(
+ document=open(f"{user.id}.png", "rb"),
+ caption=(text),
+ parse_mode=ParseMode.HTML,
+ )
- os.remove(f"{user.id}.png")
- # Incase user don't have profile pic, send normal text
- except IndexError:
+ os.remove(f"{user.id}.png")
+ # Incase user don't have profile pic, send normal text
+ except IndexError:
+ delmsg = message.reply_text(
+ text, parse_mode=ParseMode.HTML, disable_web_page_preview=True
+ )
+
+ else:
delmsg = message.reply_text(
text, parse_mode=ParseMode.HTML, disable_web_page_preview=True
- )
-
- else:
- delmsg = message.reply_text(
- text, parse_mode=ParseMode.HTML, disable_web_page_preview=True
- )
-
+ )
+
rep.delete()
-
-
+
cleartime = get_clearcmd(chat.id, "info")
-
+
if cleartime:
context.dispatcher.run_async(delete, delmsg, cleartime.time)
-
def about_me(update: Update, context: CallbackContext):
bot, args = context.bot, context.args
message = update.effective_message
@@ -434,7 +590,7 @@ def gdpr(update: Update, context: CallbackContext):
parse_mode=ParseMode.MARKDOWN)
-def __user_info__(user_id):
+def biome(user_id):
bio = html.escape(sql.get_user_bio(user_id) or "")
me = html.escape(sql.get_user_me_info(user_id) or "")
result = ""
@@ -478,7 +634,7 @@ def __gdpr__(user_id):
"""
SET_BIO_HANDLER = DisableAbleCommandHandler("setbio", set_about_bio, run_async=True)
-GET_BIO_HANDLER = DisableAbleCommandHandler("bio", about_bio)
+GET_BIO_HANDLER = DisableAbleCommandHandler("bio", about_bio, run_async=True)
STATS_HANDLER = CommandHandler("stats", stats, run_async=True)
ID_HANDLER = DisableAbleCommandHandler("id", get_id, run_async=True)
diff --git a/AstrakoBot/modules/users.py b/AstrakoBot/modules/users.py
index bdad0aff9a..f64c24e2b7 100644
--- a/AstrakoBot/modules/users.py
+++ b/AstrakoBot/modules/users.py
@@ -1,3 +1,4 @@
+import contextlib
from io import BytesIO
from time import sleep
@@ -15,6 +16,7 @@
from AstrakoBot import DEV_USERS, LOGGER, OWNER_ID, dispatcher
from AstrakoBot.modules.helper_funcs.chat_status import dev_plus, sudo_plus
from AstrakoBot.modules.sql.users_sql import get_all_users
+from AstrakoBot.modules.helper_funcs.admin_status import get_bot_member
USERS_GROUP = 4
CHAT_GROUP = 5
@@ -99,23 +101,57 @@ def broadcast(update: Update, context: CallbackContext):
)
-def log_user(update: Update, context: CallbackContext):
+def log_user(update: Update, _: CallbackContext):
chat = update.effective_chat
msg = update.effective_message
sql.update_user(msg.from_user.id, msg.from_user.username, chat.id, chat.title)
- if msg.reply_to_message:
+ if rep := msg.reply_to_message:
sql.update_user(
- msg.reply_to_message.from_user.id,
- msg.reply_to_message.from_user.username,
+ rep.from_user.id,
+ rep.from_user.username,
chat.id,
chat.title,
)
+ if rep.forward_from:
+ sql.update_user(
+ rep.forward_from.id,
+ rep.forward_from.username,
+ )
+
+ if rep.entities:
+ for entity in rep.entities:
+ if entity.type in ["text_mention", "mention"]:
+ with contextlib.suppress(AttributeError):
+ sql.update_user(entity.user.id, entity.user.username)
+ if rep.sender_chat and not rep.is_automatic_forward:
+ sql.update_user(
+ rep.sender_chat.id,
+ rep.sender_chat.username,
+ chat.id,
+ chat.title,
+ )
+
if msg.forward_from:
sql.update_user(msg.forward_from.id, msg.forward_from.username)
+ if msg.entities:
+ for entity in msg.entities:
+ if entity.type in ["text_mention", "mention"]:
+ with contextlib.suppress(AttributeError):
+ sql.update_user(entity.user.id, entity.user.username)
+
+ if msg.new_chat_members:
+ for user in msg.new_chat_members:
+ if user.id == msg.from_user.id: # we already added that in the first place
+ continue
+ sql.update_user(user.id, user.username, chat.id, chat.title)
+
+ if req := update.chat_join_request:
+ sql.update_user(req.from_user.id, req.from_user.username, chat.id, chat.title)
+
@sudo_plus
def chats(update: Update, context: CallbackContext):
@@ -146,9 +182,9 @@ def chats(update: Update, context: CallbackContext):
def chat_checker(update: Update, context: CallbackContext):
bot = context.bot
try:
- if update.effective_message.chat.get_member(bot.id).can_send_messages is False:
+ if get_bot_member(update.effective_chat.id).can_send_messages is False:
bot.leaveChat(update.effective_message.chat.id)
- except Unauthorized:
+ except:
pass
diff --git a/AstrakoBot/modules/wallpaper.py b/AstrakoBot/modules/wallpaper.py
index 3b42e8e2b9..3004eaa4db 100644
--- a/AstrakoBot/modules/wallpaper.py
+++ b/AstrakoBot/modules/wallpaper.py
@@ -1,6 +1,6 @@
from random import randint
-import requests as r
+import requests
from AstrakoBot import SUPPORT_CHAT, WALL_API, dispatcher
from AstrakoBot.modules.disable import DisableAbleCommandHandler
from AstrakoBot.modules.sql.clear_cmd_sql import get_clearcmd
@@ -8,8 +8,7 @@
from telegram import Update
from telegram.ext import CallbackContext, run_async
-# Wallpapers module by @TheRealPhoenix using wall.alphacoders.com
-
+PIXABAY_API = WALL_API
def wall(update: Update, context: CallbackContext):
chat_id = update.effective_chat.id
@@ -23,21 +22,20 @@ def wall(update: Update, context: CallbackContext):
return
else:
caption = query
- term = query.replace(" ", "%20")
- json_rep = r.get(
- f"https://wall.alphacoders.com/api2.0/get.php?auth={WALL_API}&method=search&term={term}"
- ).json()
- if not json_rep.get("success"):
+ term = query.replace(" ", "+")
+ response = requests.get(f"https://pixabay.com/api/?key={PIXABAY_API}&q={term}&image_type=photo&per_page=200")
+
+ if response.status_code != 200:
msg.reply_text(f"An error occurred! Report this @{SUPPORT_CHAT}")
else:
- wallpapers = json_rep.get("wallpapers")
+ data = response.json()
+ wallpapers = data.get("hits")
if not wallpapers:
msg.reply_text("No results found! Refine your search.")
return
else:
- index = randint(0, len(wallpapers) - 1) # Choose random index
- wallpaper = wallpapers[index]
- wallpaper = wallpaper.get("url_image")
+ index = randint(0, len(wallpapers) - 1) if len(wallpapers) > 1 else 0
+ wallpaper = wallpapers[index].get("largeImageURL")
wallpaper = wallpaper.replace("\\", "")
delmsg_preview = bot.send_photo(
chat_id,
diff --git a/AstrakoBot/modules/warns.py b/AstrakoBot/modules/warns.py
index 2858d32d2b..8e93602887 100644
--- a/AstrakoBot/modules/warns.py
+++ b/AstrakoBot/modules/warns.py
@@ -8,10 +8,11 @@
from AstrakoBot.modules.helper_funcs.chat_status import (
bot_admin,
can_restrict,
- is_user_admin,
user_admin,
+ user_can_ban,
user_admin_no_reply,
can_delete,
+ is_user_ban_protected,
)
from AstrakoBot.modules.helper_funcs.extraction import (
extract_text,
@@ -23,6 +24,7 @@
from AstrakoBot.modules.helper_funcs.string_handling import split_quotes
from AstrakoBot.modules.log_channel import loggable
from AstrakoBot.modules.sql import warns_sql as sql
+from AstrakoBot.modules.helper_funcs.admin_status import user_is_admin
from telegram import (
CallbackQuery,
Chat,
@@ -54,8 +56,8 @@
def warn(
user: User, chat: Chat, reason: str, message: Message, warner: User = None
) -> str:
- if is_user_admin(chat, user.id):
- # message.reply_text("Damn admins, They are too far to be One Punched!")
+ if is_user_ban_protected(chat, user.id):
+ message.reply_text("Damn admins, They are too far to be One Punched!")
return
if user.id in WHITELIST_USERS:
@@ -85,7 +87,7 @@ def warn(
)
else: # ban
- chat.kick_member(user.id)
+ chat.ban_member(user.id)
reply = (
f"āBan Event\n"
f" ā¢ User: {mention_html(user.id, user.first_name)}\n"
@@ -135,7 +137,7 @@ def warn(
)
try:
- message.reply_text(reply, reply_markup=keyboard, parse_mode=ParseMode.HTML)
+ message.reply_text(reply, reply_markup=keyboard, parse_mode=ParseMode.HTML, allow_sending_without_reply=True)
except BadRequest as excp:
if excp.message == "Reply message not found":
# Do not reply
@@ -179,6 +181,7 @@ def button(update: Update, context: CallbackContext) -> str:
@user_admin
+@user_can_ban
@can_restrict
@loggable
def warn_user(update: Update, context: CallbackContext) -> str:
@@ -194,6 +197,7 @@ def warn_user(update: Update, context: CallbackContext) -> str:
if (
message.reply_to_message
and message.reply_to_message.from_user.id == user_id
+ and not message.text.startswith("/d")
):
return warn(
message.reply_to_message.from_user,
@@ -208,8 +212,34 @@ def warn_user(update: Update, context: CallbackContext) -> str:
message.reply_text("That looks like an invalid User ID to me.")
return ""
+@user_admin
+@user_can_ban
+@bot_admin
+@loggable
+def rm_last_warn(update: Update, context: CallbackContext) -> str:
+ args = context.args
+ message: Optional[Message] = update.effective_message
+ chat: Optional[Chat] = update.effective_chat
+ user: Optional[User] = update.effective_user
+
+ user_id = extract_user(message, args)
+
+ if user_id:
+ sql.remove_warn(user_id, chat.id)
+ message.reply_text("Latest warning has been removed!")
+ unwarned = chat.get_member(user_id).user
+ return (
+ f"{html.escape(chat.title)}:\n"
+ f"#UNWARN\n"
+ f"Admin: {mention_html(user.id, user.first_name)}\n"
+ f"User: {mention_html(unwarned.id, unwarned.first_name)}"
+ )
+ else:
+ message.reply_text("No user has been designated!")
+ return ""
@user_admin
+@user_can_ban
@bot_admin
@loggable
def reset_warns(update: Update, context: CallbackContext) -> str:
@@ -266,6 +296,7 @@ def warns(update: Update, context: CallbackContext):
# Dispatcher handler stop - do not async
@user_admin
+@user_can_ban
def add_warn_filter(update: Update, context: CallbackContext):
chat: Optional[Chat] = update.effective_chat
msg: Optional[Message] = update.effective_message
@@ -299,6 +330,7 @@ def add_warn_filter(update: Update, context: CallbackContext):
@user_admin
+@user_can_ban
def remove_warn_filter(update: Update, context: CallbackContext):
chat: Optional[Chat] = update.effective_chat
msg: Optional[Message] = update.effective_message
@@ -383,6 +415,7 @@ def reply_filter(update: Update, context: CallbackContext) -> str:
@user_admin
+@user_can_ban
@loggable
def set_warn_limit(update: Update, context: CallbackContext) -> str:
args = context.args
@@ -394,6 +427,8 @@ def set_warn_limit(update: Update, context: CallbackContext) -> str:
if args[0].isdigit():
if int(args[0]) < 3:
msg.reply_text("The minimum warn limit is 3!")
+ elif int(args[0]) > 9999:
+ msg.reply_text("Well damn, that's a too big value!")
else:
sql.set_warn_limit(chat.id, int(args[0]))
msg.reply_text("Updated the warn limit to {}".format(args[0]))
@@ -413,6 +448,7 @@ def set_warn_limit(update: Update, context: CallbackContext) -> str:
@user_admin
+@user_can_ban
def set_warn_strength(update: Update, context: CallbackContext):
args = context.args
chat: Optional[Chat] = update.effective_chat
@@ -490,6 +526,7 @@ def __chat_settings__(chat_id, user_id):
*Admins only:*
ā¢ `/warn {}\nCreator: {}".format(
- html.escape(chat.title), chat.id, html.escape(creator)
- ),
- parse_mode=ParseMode.HTML,
- )
- else:
- bot.send_message(
- JOIN_LOGGER,
- "#NEW_GROUP\nGroup name: {}\nID: {}".format(
- html.escape(chat.title), chat.id
- ),
- parse_mode=ParseMode.HTML,
- )
- update.effective_message.reply_text(
- "Hello everybody!", reply_to_message_id=reply
- )
- continue
+ # Welcome Sudos
+ elif new_mem.id in SUDO_USERS:
+ deletion(update, context, dispatcher.bot.send_message(chat.id,
+ "Huh! A sudo user just joined! Stay Alert!",
+ ))
+ welcome_log = (
+ f"{html.escape(chat.title)}\n"
+ f"#USER_JOINED\n"
+ f"Bot Sudo just joined the group"
+ )
- else:
- buttons = sql.get_welc_buttons(chat.id)
- keyb = build_keyboard(buttons)
+ # Welcome Support
+ elif new_mem.id in SUPPORT_USERS:
+ deletion(update, context, dispatcher.bot.send_message(chat.id,
+ "Huh! A support user just joined!",
+ ))
+ welcome_log = (
+ f"{html.escape(chat.title)}\n"
+ f"#USER_JOINED\n"
+ f"Bot Support just joined the group"
+ )
- if welc_type not in (sql.Types.TEXT, sql.Types.BUTTON_TEXT):
- media_wel = True
-
- first_name = (
- new_mem.first_name or "PersonWithNoName"
- ) # edge case of empty name - occurs for some bugs.
-
- if cust_welcome:
- if cust_welcome == sql.DEFAULT_WELCOME:
- cust_welcome = random.choice(
- sql.DEFAULT_WELCOME_MESSAGES
- ).format(first=escape_markdown(first_name))
-
- if new_mem.last_name:
- fullname = escape_markdown(f"{first_name} {new_mem.last_name}")
- else:
- fullname = escape_markdown(first_name)
- count = chat.get_member_count()
- mention = mention_markdown(new_mem.id, escape_markdown(first_name))
- if new_mem.username:
- username = "@" + escape_markdown(new_mem.username)
- else:
- username = mention
-
- valid_format = escape_invalid_curly_brackets(
- cust_welcome, VALID_WELCOME_FORMATTERS
- )
- res = valid_format.format(
- first=escape_markdown(first_name),
- last=escape_markdown(new_mem.last_name or first_name),
- fullname=escape_markdown(fullname),
- username=username,
- mention=mention,
- count=count,
- chatname=escape_markdown(chat.title),
- id=new_mem.id,
- )
+ # Welcome Whitelisted
+ elif new_mem.id in WHITELIST_USERS:
+ deletion(update, context, dispatcher.bot.send_message(chat.id,
+ "Oof! A whitelist user just joined!",
+ ))
+ welcome_log = (
+ f"{html.escape(chat.title)}\n"
+ f"#USER_JOINED\n"
+ f"Bot whitelisted just joined the group"
+ )
+
+ # Welcome yourself
+ elif new_mem.id == bot.id:
+ dispatcher.bot.send_message(chat.id,
+ "Thanks for adding me! Join https://t.me/AstrakoBotSupport for support.",
+ disable_web_page_preview=True,
+ )
+
+ bot.send_message(
+ JOIN_LOGGER,
+ "#NEW_GROUP\nGroup name: {}\nID: {}".format(
+ html.escape(chat.title), chat.id
+ ),
+ parse_mode=ParseMode.HTML,
+ )
+ else:
+ buttons = sql.get_welc_buttons(chat.id)
+ keyb = build_keyboard(buttons)
+
+ if welc_type not in (sql.Types.TEXT, sql.Types.BUTTON_TEXT):
+ media_wel = True
+
+ first_name = (
+ new_mem.first_name or "PersonWithNoName"
+ ) # edge case of empty name - occurs for some bugs.
+
+ if cust_welcome:
+ if cust_welcome == sql.DEFAULT_WELCOME:
+ cust_welcome = random.choice(
+ sql.DEFAULT_WELCOME_MESSAGES
+ ).format(first=escape_markdown(first_name))
+ if new_mem.last_name:
+ fullname = escape_markdown(f"{first_name} {new_mem.last_name}")
else:
- res = random.choice(sql.DEFAULT_WELCOME_MESSAGES).format(
- first=escape_markdown(first_name)
- )
- keyb = []
+ fullname = escape_markdown(first_name)
+ count = chat.get_member_count()
+ mention = mention_markdown(new_mem.id, escape_markdown(first_name))
+ if new_mem.username:
+ username = "@" + escape_markdown(new_mem.username)
+ else:
+ username = mention
- backup_message = random.choice(sql.DEFAULT_WELCOME_MESSAGES).format(
+ valid_format = escape_invalid_curly_brackets(
+ cust_welcome, VALID_WELCOME_FORMATTERS
+ )
+ res = valid_format.format(
+ first=escape_markdown(first_name),
+ last=escape_markdown(new_mem.last_name or first_name),
+ fullname=escape_markdown(fullname),
+ username=username,
+ mention=mention,
+ count=count,
+ chatname=escape_markdown(chat.title),
+ id=new_mem.id,
+ )
+
+ else:
+ res = random.choice(sql.DEFAULT_WELCOME_MESSAGES).format(
first=escape_markdown(first_name)
)
- keyboard = InlineKeyboardMarkup(keyb)
+ keyb = []
- else:
- welcome_bool = False
- res = None
- keyboard = None
- backup_message = None
- reply = None
-
- # User exceptions from welcomemutes
- if (
- is_user_ban_protected(chat, new_mem.id, chat.get_member(new_mem.id))
- or human_checks
- ):
- should_mute = False
- # Join welcome: soft mute
- if new_mem.is_bot:
- should_mute = False
-
- if user.id == new_mem.id:
- if should_mute:
- if welc_mutes == "soft":
- bot.restrict_chat_member(
- chat.id,
- new_mem.id,
- permissions=ChatPermissions(
- can_send_messages=True,
- can_send_media_messages=False,
- can_send_other_messages=False,
- can_invite_users=False,
- can_pin_messages=False,
- can_send_polls=False,
- can_change_info=False,
- can_add_web_page_previews=False,
- ),
- until_date=(int(time.time() + 24 * 60 * 60)),
+ backup_message = random.choice(sql.DEFAULT_WELCOME_MESSAGES).format(
+ first=escape_markdown(first_name)
+ )
+ keyboard = InlineKeyboardMarkup(keyb)
+ else:
+ welcome_bool = False
+ backup_message = None
+
+ # User exceptions from welcomemutes
+ if (
+ is_user_ban_protected(chat, new_mem.id, chat.get_member(new_mem.id))
+ or human_checks
+ ):
+ should_mute = False
+ # Join welcome: soft mute
+ if new_mem.is_bot:
+ should_mute = False
+
+ if user.id == new_mem.id:
+ if should_mute:
+ if welc_mutes == "soft":
+ bot.restrict_chat_member(
+ chat.id,
+ new_mem.id,
+ permissions=ChatPermissions(
+ can_send_messages=True,
+ can_send_media_messages=False,
+ can_send_other_messages=False,
+ can_invite_users=False,
+ can_pin_messages=False,
+ can_send_polls=False,
+ can_change_info=False,
+ can_add_web_page_previews=False,
+ ),
+ until_date=(int(time.time() + 24 * 60 * 60)),
+ )
+ if welc_mutes == "strong":
+ welcome_bool = False
+ if not media_wel:
+ VERIFIED_USER_WAITLIST.update(
+ {
+ new_mem.id: {
+ "should_welc": should_welc,
+ "media_wel": False,
+ "status": False,
+ "update": update,
+ "res": res,
+ "keyboard": keyboard,
+ "backup_message": backup_message,
+ }
+ }
)
- if welc_mutes == "strong":
- welcome_bool = False
- if not media_wel:
- VERIFIED_USER_WAITLIST.update(
- {
- new_mem.id: {
- "should_welc": should_welc,
- "media_wel": False,
- "status": False,
- "update": update,
- "res": res,
- "keyboard": keyboard,
- "backup_message": backup_message,
- }
+ else:
+ VERIFIED_USER_WAITLIST.update(
+ {
+ new_mem.id: {
+ "should_welc": should_welc,
+ "chat_id": chat.id,
+ "status": False,
+ "media_wel": True,
+ "cust_content": cust_content,
+ "welc_type": welc_type,
+ "res": res,
+ "keyboard": keyboard,
}
- )
- else:
- VERIFIED_USER_WAITLIST.update(
+ }
+ )
+ new_join_mem = f'{html.escape(new_mem.first_name)}'
+ message = dispatcher.bot.send_message(chat.id,
+ f"{new_join_mem}, click the button below to prove you're human.\nYou have 60 seconds.",
+ reply_markup=InlineKeyboardMarkup(
+ [
{
- new_mem.id: {
- "should_welc": should_welc,
- "chat_id": chat.id,
- "status": False,
- "media_wel": True,
- "cust_content": cust_content,
- "welc_type": welc_type,
- "res": res,
- "keyboard": keyboard,
- }
+ InlineKeyboardButton(
+ text="Yes, I'm human.",
+ callback_data=f"user_join_({new_mem.id})",
+ )
}
- )
- new_join_mem = f'{html.escape(new_mem.first_name)}'
- message = msg.reply_text(
- f"{new_join_mem}, click the button below to prove you're human.\nYou have 60 seconds.",
- reply_markup=InlineKeyboardMarkup(
- [
- {
- InlineKeyboardButton(
- text="Yes, I'm human.",
- callback_data=f"user_join_({new_mem.id})",
- )
- }
- ]
- ),
- parse_mode=ParseMode.HTML,
- reply_to_message_id=reply,
- )
+ ]
+ ),
+ parse_mode=ParseMode.HTML,
+ )
+ if get_bot_member(chat.id).can_restrict_members:
bot.restrict_chat_member(
chat.id,
new_mem.id,
@@ -435,62 +427,72 @@ def new_member(update: Update, context: CallbackContext):
can_add_web_page_previews=False,
),
)
- job_queue.run_once(
- partial(check_not_bot, new_mem, chat.id, message.message_id),
- 60,
- name="welcomemute",
- )
+ job_queue.run_once(
+ partial(check_not_bot, new_mem, chat.id, message.message_id),
+ 60,
+ name="welcomemute",
+ )
- if welcome_bool:
- if media_wel:
+ if welcome_bool:
+ if media_wel:
+ # Stickers have no caption, send separately
+ if welc_type == sql.Types.STICKER:
+ sent = ENUM_FUNC_MAP[welc_type](
+ chat.id,
+ cust_content,
+ reply_markup=keyboard
+ ) and ENUM_FUNC_MAP[sql.Types.TEXT](
+ chat.id,
+ res,
+ parse_mode="markdown"
+ )
+ else:
sent = ENUM_FUNC_MAP[welc_type](
chat.id,
cust_content,
caption=res,
reply_markup=keyboard,
- reply_to_message_id=reply,
- parse_mode="markdown",
+ parse_mode="markdown"
)
- else:
- sent = send(update, res, keyboard, backup_message)
- deletion(update, context, sent)
- prev_welc = sql.get_clean_pref(chat.id)
- if prev_welc:
- try:
- bot.delete_message(chat.id, prev_welc)
- except BadRequest:
- pass
-
- if sent:
- sql.set_clean_welcome(chat.id, sent.message_id)
+ else:
+ sent = send(update, res, keyboard, backup_message)
+ deletion(update, context, sent)
+ prev_welc = sql.get_clean_pref(chat.id)
+ if prev_welc:
+ try:
+ bot.delete_message(chat.id, prev_welc)
+ except BadRequest:
+ pass
- if welcome_log:
- return welcome_log
+ if sent:
+ sql.set_clean_welcome(chat.id, sent.message_id)
- if user.id == new_mem.id:
- welcome_log = (
- f"{html.escape(chat.title)}\n"
- f"#USER_JOINED\n"
- f"User: {mention_html(user.id, user.first_name)}\n"
- f"ID: {user.id}"
- )
- elif new_mem.is_bot and user.id != new_mem.id:
- welcome_log = (
- f"{html.escape(chat.title)}\n"
- f"#BOT_ADDED\n"
- f"Bot: {mention_html(new_mem.id, new_mem.first_name)}\n"
- f"ID: {new_mem.id}"
- )
- else:
- welcome_log = (
- f"{html.escape(chat.title)}\n"
- f"#USER_ADDED\n"
- f"User: {mention_html(new_mem.id, new_mem.first_name)}\n"
- f"ID: {new_mem.id}"
- )
+ if welcome_log:
return welcome_log
- return ""
+ if user.id == new_mem.id:
+ welcome_log = (
+ f"{html.escape(chat.title)}\n"
+ f"#USER_JOINED\n"
+ f"User: {mention_html(user.id, user.first_name)}\n"
+ f"ID: {user.id}"
+ )
+ elif new_mem.is_bot and user.id != new_mem.id:
+ welcome_log = (
+ f"{html.escape(chat.title)}\n"
+ f"#BOT_ADDED\n"
+ f"Bot: {mention_html(new_mem.id, new_mem.first_name)}\n"
+ f"ID: {new_mem.id}"
+ )
+ else:
+ welcome_log = (
+ f"{html.escape(chat.title)}\n"
+ f"#USER_ADDED\n"
+ f"User: {mention_html(new_mem.id, new_mem.first_name)}\n"
+ f"ID: {new_mem.id}"
+ )
+ return welcome_log
+
def check_not_bot(member, chat_id, message_id, context):
@@ -514,6 +516,19 @@ def check_not_bot(member, chat_id, message_id, context):
pass
+def cleanServiceFilter(u: Update, _):
+ if u.effective_message.left_chat_member or u.effective_message.new_chat_members:
+ return handleCleanService(u)
+
+
+def handleCleanService(update: Update):
+ if sql.clean_service(update.effective_chat.id):
+ try:
+ dispatcher.bot.delete_message(update.effective_chat.id, update.message.message_id)
+ except BadRequest:
+ pass
+
+
def left_member(update: Update, context: CallbackContext):
bot = context.bot
chat = update.effective_chat
@@ -524,17 +539,8 @@ def left_member(update: Update, context: CallbackContext):
return
if should_goodbye:
- reply = update.message.message_id
- cleanserv = sql.clean_service(chat.id)
- # Clean service welcome
- if cleanserv:
- try:
- dispatcher.bot.delete_message(chat.id, update.message.message_id)
- except BadRequest:
- pass
- reply = False
- left_mem = update.effective_message.left_chat_member
+ left_mem = update.chat_member.new_chat_member.user
if left_mem:
# Thingy for spamwatched users
@@ -553,16 +559,15 @@ def left_member(update: Update, context: CallbackContext):
# Give the owner a special goodbye
if left_mem.id == OWNER_ID:
- update.effective_message.reply_text(
- "Oi! Genos! He left..", reply_to_message_id=reply
+ dispatcher.bot.send_message(chat.id,
+ "Oi! Genos! He left..",
)
return
# Give the devs a special goodbye
elif left_mem.id in DEV_USERS:
- update.effective_message.reply_text(
+ dispatcher.bot.send_message(chat.id,
"See you later dev!",
- reply_to_message_id=reply,
)
return
@@ -624,13 +629,29 @@ def left_member(update: Update, context: CallbackContext):
deletion(update, context, delmsg)
+def get_welcome_kwargs(welcome_type, chat, welcome_m, keyboard):
+ kwargs = {
+ 'reply_markup': keyboard,
+ }
+
+ # Add caption (except for stickers)
+ if welcome_type != sql.Types.STICKER:
+ kwargs['caption'] = welcome_m
+ kwargs['parse_mode'] = ParseMode.MARKDOWN
+
+ # Add web preview disable (only for supported types)
+ if welcome_type in {sql.Types.TEXT, sql.Types.PHOTO}:
+ kwargs['disable_web_page_preview'] = True
+
+ return kwargs
+
@user_admin
def welcome(update: Update, context: CallbackContext):
args = context.args
chat = update.effective_chat
# if no args, show current replies.
if not args or args[0].lower() == "noformat":
- noformat = True
+ noformat = bool(args and args[0].lower() == "noformat")
pref, welcome_m, cust_content, welcome_type = sql.get_welc_pref(chat.id)
update.effective_message.reply_text(
f"This chat has it's welcome setting set to: `{pref}`.\n"
@@ -638,7 +659,7 @@ def welcome(update: Update, context: CallbackContext):
parse_mode=ParseMode.MARKDOWN,
)
- if welcome_type == sql.Types.BUTTON_TEXT or welcome_type == sql.Types.TEXT:
+ if welcome_type in [sql.Types.BUTTON_TEXT, sql.Types.TEXT]:
buttons = sql.get_welc_buttons(chat.id)
if noformat:
welcome_m += revert_buttons(buttons)
@@ -652,20 +673,17 @@ def welcome(update: Update, context: CallbackContext):
else:
buttons = sql.get_welc_buttons(chat.id)
if noformat:
- welcome_m += revert_buttons(buttons)
- ENUM_FUNC_MAP[welcome_type](chat.id, cust_content, caption=welcome_m)
+ if welcome_m:
+ welcome_m += revert_buttons(buttons)
+ ENUM_FUNC_MAP[welcome_type](chat.id, cust_content, caption=welcome_m)
+ else:
+ ENUM_FUNC_MAP[welcome_type](chat.id, cust_content)
else:
keyb = build_keyboard(buttons)
keyboard = InlineKeyboardMarkup(keyb)
- ENUM_FUNC_MAP[welcome_type](
- chat.id,
- cust_content,
- caption=welcome_m,
- reply_markup=keyboard,
- parse_mode=ParseMode.MARKDOWN,
- disable_web_page_preview=True,
- )
+ kwargs = get_welcome_kwargs(welcome_type, chat, welcome_m, keyboard)
+ ENUM_FUNC_MAP[welcome_type](chat.id, cust_content, **kwargs)
elif len(args) >= 1:
if args[0].lower() in ("on", "yes"):
@@ -692,7 +710,7 @@ def goodbye(update: Update, context: CallbackContext):
chat = update.effective_chat
if not args or args[0] == "noformat":
- noformat = True
+ noformat = bool(args and args[0].lower() == "noformat")
pref, goodbye_m, goodbye_type = sql.get_gdbye_pref(chat.id)
update.effective_message.reply_text(
f"This chat has it's goodbye setting set to: `{pref}`.\n"
@@ -712,14 +730,13 @@ def goodbye(update: Update, context: CallbackContext):
send(update, goodbye_m, keyboard, sql.DEFAULT_GOODBYE)
- else:
- if noformat:
- ENUM_FUNC_MAP[goodbye_type](chat.id, goodbye_m)
+ elif noformat:
+ ENUM_FUNC_MAP[goodbye_type](chat.id, goodbye_m)
- else:
- ENUM_FUNC_MAP[goodbye_type](
- chat.id, goodbye_m, parse_mode=ParseMode.MARKDOWN
- )
+ else:
+ ENUM_FUNC_MAP[goodbye_type](
+ chat.id, goodbye_m, parse_mode=ParseMode.MARKDOWN
+ )
elif len(args) >= 1:
if args[0].lower() in ("on", "yes"):
@@ -968,33 +985,45 @@ def user_button(update: Update, context: CallbackContext):
member_dict["status"] = True
VERIFIED_USER_WAITLIST.update({user.id: member_dict})
query.answer(text="Yeet! You're a human, unmuted!")
- bot.restrict_chat_member(
- chat.id,
- user.id,
- permissions=ChatPermissions(
- can_send_messages=True,
- can_invite_users=True,
- can_pin_messages=True,
- can_send_polls=True,
- can_change_info=True,
- can_send_media_messages=True,
- can_send_other_messages=True,
- can_add_web_page_previews=True,
- ),
- )
+ if get_bot_member(chat.id).can_restrict_members:
+ bot.restrict_chat_member(
+ chat.id,
+ user.id,
+ permissions=ChatPermissions(
+ can_send_messages=True,
+ can_invite_users=True,
+ can_pin_messages=True,
+ can_send_polls=True,
+ can_change_info=True,
+ can_send_media_messages=True,
+ can_send_other_messages=True,
+ can_add_web_page_previews=True,
+ ),
+ )
try:
bot.deleteMessage(chat.id, message.message_id)
except:
pass
if member_dict["should_welc"]:
if member_dict["media_wel"]:
- sent = ENUM_FUNC_MAP[member_dict["welc_type"]](
- member_dict["chat_id"],
- member_dict["cust_content"],
- caption=member_dict["res"],
- reply_markup=member_dict["keyboard"],
- parse_mode="markdown",
- )
+ if member_dict["welc_type"] == sql.Types.STICKER:
+ sent = ENUM_FUNC_MAP[member_dict["welc_type"]](
+ member_dict["chat_id"],
+ member_dict["cust_content"],
+ reply_markup=member_dict["keyboard"],
+ ) and ENUM_FUNC_MAP[sql.Types.TEXT](
+ member_dict["chat_id"],
+ member_dict["res"],
+ parse_mode="markdown",
+ )
+ else:
+ sent = ENUM_FUNC_MAP[member_dict["welc_type"]](
+ member_dict["chat_id"],
+ member_dict["cust_content"],
+ caption=member_dict["res"],
+ reply_markup=member_dict["keyboard"],
+ parse_mode="markdown",
+ )
else:
sent = send(
member_dict["update"],
@@ -1118,8 +1147,15 @@ def __chat_settings__(chat_id, user_id):
ā¢ `/welcomehelp`*:* view more formatting information for custom welcome/goodbye messages.
"""
-NEW_MEM_HANDLER = MessageHandler(Filters.status_update.new_chat_members, new_member, run_async=True)
-LEFT_MEM_HANDLER = MessageHandler(Filters.status_update.left_chat_member, left_member, run_async=True)
+dispatcher.add_handler(
+ ChatMemberHandler(
+ welcomeFilter, ChatMemberHandler.CHAT_MEMBER, run_async=True
+ ), group=-100)
+
+dispatcher.add_handler(
+ MessageHandler(Filters.chat_type.groups, cleanServiceFilter), group=100)
+
+
WELC_PREF_HANDLER = CommandHandler("welcome", welcome, filters=Filters.chat_type.groups, run_async=True)
GOODBYE_PREF_HANDLER = CommandHandler("goodbye", goodbye, filters=Filters.chat_type.groups, run_async=True)
SET_WELCOME = CommandHandler("setwelcome", set_welcome, filters=Filters.chat_type.groups, run_async=True)
@@ -1135,8 +1171,6 @@ def __chat_settings__(chat_id, user_id):
WELCOME_MUTE_HELP = CommandHandler("welcomemutehelp", welcome_mute_help, run_async=True)
BUTTON_VERIFY_HANDLER = CallbackQueryHandler(user_button, pattern=r"user_join_", run_async=True)
-dispatcher.add_handler(NEW_MEM_HANDLER)
-dispatcher.add_handler(LEFT_MEM_HANDLER)
dispatcher.add_handler(WELC_PREF_HANDLER)
dispatcher.add_handler(GOODBYE_PREF_HANDLER)
dispatcher.add_handler(SET_WELCOME)
@@ -1153,8 +1187,6 @@ def __chat_settings__(chat_id, user_id):
__mod_name__ = "Welcomes/Goodbyes"
__command_list__ = []
__handlers__ = [
- NEW_MEM_HANDLER,
- LEFT_MEM_HANDLER,
WELC_PREF_HANDLER,
GOODBYE_PREF_HANDLER,
SET_WELCOME,
diff --git a/AstrakoBot/modules/wiki.py b/AstrakoBot/modules/wiki.py
index bce0262180..d4b7b31726 100644
--- a/AstrakoBot/modules/wiki.py
+++ b/AstrakoBot/modules/wiki.py
@@ -28,7 +28,7 @@ def wiki(update: Update, context: CallbackContext):
msg += f"Read more: https://en.wikipedia.org/wiki/{definition}"
if len(msg) > 4000:
with open("result.txt", "w") as f:
- f.write(f"{result}\n\nUwU OwO OmO UmU")
+ f.write(f"{res}\n\nUwU OwO OmO UmU")
with open("result.txt", "rb") as f:
delmsg = context.bot.send_document(
document=f,
diff --git a/AstrakoBot/modules/youtube.py b/AstrakoBot/modules/youtube.py
index e6765e0ac1..fc5b084bdb 100644
--- a/AstrakoBot/modules/youtube.py
+++ b/AstrakoBot/modules/youtube.py
@@ -1,173 +1,155 @@
-import os, glob, json
-
+import os
+import json
+import random
+import string
from datetime import datetime
-from AstrakoBot.modules.sql.clear_cmd_sql import get_clearcmd
from telegram import Bot, Update, ParseMode, InlineKeyboardButton, InlineKeyboardMarkup
from telegram.ext import CommandHandler, CallbackQueryHandler, CallbackContext, run_async
+from AstrakoBot.modules.sql.clear_cmd_sql import get_clearcmd
from AstrakoBot import dispatcher
from AstrakoBot.modules.disable import DisableAbleCommandHandler
from AstrakoBot.modules.helper_funcs.misc import delete
-from youtubesearchpython import VideosSearch
+import pytube
+from moviepy.editor import *
-from youtube_dl import YoutubeDL
+def get_random():
+ letters = string.ascii_lowercase
+ return ''.join(random.choice(letters) for i in range(10))
+def is_ytl(url):
+ return 'youtube.com/watch?v=' in url or 'youtu.be/' in url
-def youtube(update: Update, context: CallbackContext):
- bot = context.bot
- message = update.effective_message
- chat = update.effective_chat
- yt = message.text[len("/youtube ") :]
- if yt:
- search = VideosSearch(yt, limit=1)
- result = search.result()
+def format_link(youtube_link):
+ if "youtu.be/" in youtube_link:
+ youtube_link = youtube_link.replace('youtu.be/', 'youtube.com/watch?v=')
+ if '&ab_channel' in youtube_link:
+ youtube_link = youtube_link.split('&ab_channel')[0]
+ return youtube_link
+
+def dyt_video(youtube_link, resolution, filename):
+ youtube_link = format_link(youtube_link)
+ youtube = pytube.YouTube(youtube_link)
+ # Try to get video length at least 5 times
+ for i in range(5):
try:
- url = result["result"][0]["link"]
- title = result["result"][0]["title"]
+ video_length = youtube.length / 60
+ break
except:
- return message.reply_text(
- "Failed to find song or video",
- )
-
- buttons = [
- [
- InlineKeyboardButton("šµ", callback_data=f"youtube;audio;{url}"),
- InlineKeyboardButton("š„", callback_data=f"youtube;video;{url}"),
- InlineKeyboardButton("š«", callback_data=f"youtube;cancel;"""),
- ]
- ]
-
- msg = "*Preparing to upload file:*\n"
- msg += f"`{title}`\n"
- delmsg = message.reply_text(
- msg,
- parse_mode=ParseMode.MARKDOWN,
- reply_markup = InlineKeyboardMarkup(buttons)
- )
+ if i == 4:
+ return "Could not get video length! Try again in a few seconds or try another video."
- else:
- delmsg = message.reply_text("Specify a song or video"
- )
- cleartime = get_clearcmd(chat.id, "youtube")
-
- if cleartime:
- context.dispatcher.run_async(delete, delmsg, cleartime.time)
+ if video_length > 10: # 10 minutes limit for video
+ return "Video is longer than 10 minutes! Try again with a shorter one."
+
+ video_streams = youtube.streams
+ available_resolutions = [stream.resolution for stream in video_streams if stream.resolution is not None]
+ if resolution not in available_resolutions:
+ resolution = max(available_resolutions, key=lambda x: int(x[:-1]))
+
+ video_stream = youtube.streams.filter(resolution=resolution, progressive=True).order_by('resolution').desc().first()
+ audio_stream = youtube.streams.filter(only_audio=True).order_by('abr').desc().first()
+
+ video_file = video_stream.download(filename="{}.mp4".format(get_random()))
+ audio_file = audio_stream.download(filename="{}.mp3".format(get_random()))
+
+ video_clip = VideoFileClip(video_file)
+ audio_clip = AudioFileClip(audio_file)
+ final_clip = video_clip.set_audio(audio_clip)
+ final_clip.write_videofile(filename, codec='libx264', audio_codec='aac')
+
+ try:
+ os.remove(video_file)
+ os.remove(audio_file)
+ except:
+ pass
+
+ return ""
+
+def dyt_audio(youtube_link, filename):
+ youtube_link = format_link(youtube_link)
+ youtube = pytube.YouTube(youtube_link)
+
+ # Try to get video length at least 5 times, even with this, pytube may fail sometimes.
+ for i in range(5):
+ try:
+ video_length = youtube.length / 60
+ break
+ except:
+ if i == 5:
+ return "Could not get video length! Try again in a few seconds or try another video."
+ if video_length > 30: # 30 minutes limit for audio
+ return "Audio is longer than 30 minutes! Try again with a shorter one."
-def youtube_callback(update: Update, context: CallbackContext):
- bot = context.bot
+ audio_stream = youtube.streams.filter(only_audio=True, abr="128kbps").first()
+
+ try:
+ audio_stream.download(filename=filename)
+ except:
+ return "Unknown Error."
+ return ""
+
+def youtube(update: Update, context: CallbackContext):
+ message_id = update.message.message_id
message = update.effective_message
chat = update.effective_chat
- query = update.callback_query
-
- media = query.data.split(";")
- media_type = media[1]
- media_url = media[2]
-
- if media_type == "audio":
- deltext = message.edit_text("Processing song...")
- opts = {
- "format": "bestaudio/best",
- "addmetadata": True,
- "geo_bypass": True,
- "nocheckcertificate": True,
- "postprocessors": [
- {
- "key": "FFmpegExtractAudio",
- "preferredcodec": "mp3",
- "preferredquality": "128",
- }
- ],
- "outtmpl": "%(title)s.%(etx)s",
- "quiet": True,
- "logtostderr": False,
- }
-
- codec = "mp3"
-
- with YoutubeDL(opts) as rip:
- rip_data = rip.extract_info(media_url, download=False, process=False)
- if int(rip_data['duration'] / 60) < 10:
- try:
- rip_data = rip.extract_info(media_url)
- delmsg = bot.send_audio(
- chat_id = chat.id,
- audio = open(f"{rip_data['title']}.{codec}", "rb"),
- duration = int(rip_data['duration']),
- title = str(rip_data['title']),
- parse_mode = ParseMode.HTML
- )
- context.dispatcher.run_async(delete, deltext, 0)
- except:
- delmsg = message.edit_text(
- "Song is too large for processing, or any other error happened. Try again later"
- )
- else:
- delmsg = message.edit_text(
- "Song is too large for processing. Duration is limited to 10 minutes max"
- )
-
- elif media_type == "video":
- deltext = message.edit_text("Processing video...")
- opts = {
- "format": "best",
- "addmetadata": True,
- "geo_bypass": True,
- "nocheckcertificate": True,
- "postprocessors": [
- {
- "key": "FFmpegVideoConvertor",
- "preferedformat": "mp4",
- }
- ],
- "outtmpl": "%(title)s.mp4",
- "quiet": True,
- "logtostderr": False,
- }
-
- codec = "mp4"
-
- with YoutubeDL(opts) as rip:
- rip_data = rip.extract_info(media_url, download=False, process=False)
- if int(rip_data['duration'] / 60) < 10:
- try:
- rip_data = rip.extract_info(media_url)
- delmsg = bot.send_video(
- chat_id = chat.id,
- video = open(f"{rip_data['title']}.{codec}", "rb"),
- duration = int(rip_data['duration']),
- caption = rip_data['title'],
- supports_streaming = True,
- parse_mode = ParseMode.HTML
- )
- context.dispatcher.run_async(delete, deltext, 0)
- except:
- delmsg = message.edit_text(
- "Video is too large for processing, or any other error happened. Try again later"
- )
- else:
- delmsg = message.edit_text(
- "Video is too large for processing. Duration is limited to 10 minutes max"
- )
+ args = context.args
+ chat_id = update.effective_chat.id
+ if not args or not is_ytl(args[0]):
+ message.reply_text("Specify a song or video!")
+ return
+ yt = args[0]
+ avail_res = ["720p", "480p", "360p", "240p", "144p"] # Limit to HD due to file size
+ types = ["video", "audio"]
+ type = "video"
+ res = avail_res[0]
+ for i in types:
+ if i in args:
+ type = i
+ break
+ for i in avail_res:
+ if i in args or i[:-1] in args:
+ res = i
+ if not res.endswith("p"):
+ res += "p"
+ break
+
+ filename = get_random()
+
+ if type == "video":
+ filename += ".mp4"
+ msg = message.reply_text("Downloading as video, Please wait...")
+ ret = dyt_video(yt, res, filename)
+ caption = "Type: mp4\nQuality: {}".format(res)
+ if not ret:
+ msg.edit_text("Uploading...")
+ with open(filename, "rb") as video:
+ context.bot.send_video(chat_id=chat_id, video=video, caption=caption, reply_to_message_id=message_id)
+ msg.delete()
+ else:
+ msg.edit_text(ret)
+
else:
- delmsg = message.edit_text("Canceling...")
- context.dispatcher.run_async(delete, delmsg, 1)
+ filename += ".mp3"
+ msg = message.reply_text("Downloading as mp3 audio, Please wait...")
+ ret = dyt_audio(yt, filename)
+ caption = "Type: mp3\nQuality: 128kbps".format(res)
+ if not ret:
+ msg.edit_text("Uploading...")
+ with open(filename, "rb") as audio:
+ context.bot.send_audio(chat_id=chat_id, audio=audio, caption=caption.format(type), reply_to_message_id=message_id)
+ msg.delete()
+ else:
+ msg.edit_text(ret)
try:
- os.remove(f"{rip_data['title']}.{codec}")
+ os.remove(filename)
except Exception:
pass
- cleartime = get_clearcmd(chat.id, "youtube")
-
- if cleartime:
- context.dispatcher.run_async(delete, delmsg, cleartime.time)
-
+ return
YOUTUBE_HANDLER = DisableAbleCommandHandler(["youtube", "yt"], youtube, run_async = True)
-YOUTUBE_CALLBACKHANDLER = CallbackQueryHandler(
- youtube_callback, pattern="youtube*", run_async=True
-)
dispatcher.add_handler(YOUTUBE_HANDLER)
-dispatcher.add_handler(YOUTUBE_CALLBACKHANDLER)
diff --git a/AstrakoBot/sample_config.py b/AstrakoBot/sample_config.py
index cff0ed2aa0..b2a6a64133 100644
--- a/AstrakoBot/sample_config.py
+++ b/AstrakoBot/sample_config.py
@@ -3,6 +3,7 @@
import os
+
def get_user_list(config, key):
with open("{}/AstrakoBot/{}".format(os.getcwd(), config), "r") as json_file:
return json.load(json_file)[key]
@@ -30,6 +31,7 @@ class Config(object):
# RECOMMENDED
SQLALCHEMY_DATABASE_URI = "something://somewhat:user@hosturl:port/databasename" # needed for any database modules
+ DB_NAME = "databasename" # needed for cron_jobs module, use same databasename from SQLALCHEMY_DATABASE_URI
LOAD = []
NO_LOAD = ["rss", "cleaner", "connection", "math"]
WEBHOOK = False
@@ -59,16 +61,18 @@ class Config(object):
BAN_STICKER = "" # banhammer marie sticker id, the bot will send this sticker before banning or kicking a user in chat.
ALLOW_EXCL = True # Allow ! commands as well as / (Leave this to true so that blacklist can work)
CASH_API_KEY = (
- "awoo" # Get your API key from https://www.alphavantage.co/support/#api-key
+ "awoo" # Get your API key from https://app.exchangerate-api.com/dashboard
)
TIME_API_KEY = "awoo" # Get your API key from https://timezonedb.com/api
WALL_API = (
- "awoo" # For wallpapers, get one from https://wall.alphacoders.com/api.php
+ "awoo" # For wallpapers, get one from https://pixabay.com/api/docs
)
AI_API_KEY = "awoo" # For chatbot, get one from https://coffeehouse.intellivoid.net/dashboard
BL_CHATS = [] # List of groups that you want blacklisted.
SPAMMERS = None
-
+
+ BACKUP_PASS = "12345" # The password used for the cron backups zip
+ DROP_UPDATES = False # whether to drop the pending updates or not
class Production(Config):
LOGGER = True
diff --git a/README.md b/README.md
index 5bd687fd44..19c4c1d9d0 100644
--- a/README.md
+++ b/README.md
@@ -17,7 +17,7 @@
