async def spider(e):
if not e.text[0].isalpha() and e.text[0] not in ("/", "#", "@", "!"):
if (await e.get_reply_message()).sender_id in BRAIN_CHECKER:
await e.edit("`Mute Error! I am not supposed to mute this user`")
return
try:
from userbot.modules.sql_helper.spam_mute_sql import mute
except Exception:
await e.edit("`Running on Non-SQL mode!`")
return
chat = await e.get_chat()
rights = chat.admin_rights
rights2 = chat.creator
if not rights and not rights2:
await e.edit(
"`Ooof Jeepeo , We can try next time becoZ You aren't an admin in this cancerous group !`"
)
return
mute(e.chat_id, str((await e.get_reply_message()).sender_id))
await e.edit("`Gets a tape!`")
time.sleep(5)
await e.delete()
await e.respond("`Safely taped!`")
if LOGGER:
await bot.send_message(
LOGGER_GROUP,
str((await spdr.get_reply_message()).sender_id) +
" was muted.",
)
async def spider(spdr):
"""
This function is basically muting peeps
"""
if not spdr.text[0].isalpha() and spdr.text[0] not in ("/", "#", "@", "!"):
# Check if the function running under SQL mode
try:
from userbot.modules.sql_helper.spam_mute_sql import mute
except AttributeError:
await spdr.edit(NO_SQL)
return
# Admin or creator check
chat = await spdr.get_chat()
admin = chat.admin_rights
creator = chat.creator
# If not admin and not creator, return
if not admin and not creator:
await spdr.edit(NO_ADMIN)
return
user = await get_user_from_event(spdr)
if user:
pass
else:
return
self_user = await spdr.client.get_me()
if user.id == self_user.id:
await spdr.edit("`Mute Error! You are not supposed to mute yourself!`")
return
# If the targeted user is a Sudo
if user.id in BRAIN_CHECKER:
await spdr.edit(
"`Mute Error! I am not supposed to mute this user`"
)
return
# If everything goes well, do announcing and mute
await spdr.edit("`Gets a tape!`")
mute(spdr.chat_id, user.id)
# Announce that the function is done
await spdr.edit("`Safely taped!`")
# Announce to logging group
if BOTLOG:
await spdr.client.send_message(
BOTLOG_CHATID,
"#MUTE\n"
f"USER: [{user.first_name}](tg://user?id={user.id})\n"
f"CHAT: {spdr.chat.title}(`{spdr.chat_id}`)"
)
async def spider(spdr):
"""
This function is basically muting peeps
"""
# Check if the function running under SQL mode
try:
from userbot.modules.sql_helper.spam_mute_sql import mute
except AttributeError:
await spdr.edit(NO_SQL)
return
# Admin or creator check
chat = await spdr.get_chat()
admin = chat.admin_rights
creator = chat.creator
# If not admin and not creator, return
if not admin and not creator:
await spdr.edit(NO_ADMIN)
return
user, reason = await get_user_from_event(spdr)
if user:
pass
else:
return
self_user = await spdr.client.get_me()
if user.id == self_user.id:
await spdr.edit(
"`Hands too short, can't duct tape myself...\n(ヘ･_･)ヘ┳━┳`")
return
# If everything goes well, do announcing and mute
await spdr.edit("`Gets a tape!`")
if mute(spdr.chat_id, user.id) is False:
return await spdr.edit('`Error! User probably already muted.`')
else:
try:
await spdr.client(
EditBannedRequest(spdr.chat_id, user.id, MUTE_RIGHTS))
# Announce that the function is done
if reason:
await spdr.edit(
f"`Muted this gey retarded nibba !!`\nReason: {reason}")
else:
await spdr.edit(
"`nub f**k has been muted by peru `Racing_DNA_Unleashed` !!`"
)
# Announce to logging group
if BOTLOG:
await spdr.client.send_message(
BOTLOG_CHATID, "#MUTE\n"
f"USER: [{user.first_name}](tg://user?id={user.id})\n"
f"CHAT: {spdr.chat.title}(`{spdr.chat_id}`)")
except UserIdInvalidError:
return await spdr.edit("`Uh oh my mute logic broke!`")
async def spider(spdr):
"""
This function is basically muting peeps
"""
# Check if the function running under SQL mode
try:
from userbot.modules.sql_helper.spam_mute_sql import mute
except AttributeError:
return await spdr.edit(NO_SQL)
# Admin or creator check
chat = await spdr.get_chat()
admin = chat.admin_rights
creator = chat.creator
# If not admin and not creator, return
if not admin and not creator:
return await spdr.edit(NO_ADMIN)
user, reason = await get_user_from_event(spdr)
if user:
pass
else:
return
self_user = await spdr.client.get_me()
if user.id == self_user.id:
return await spdr.edit("`Saya tidak bisa membisukan!`")
# If everything goes well, do announcing and mute
await spdr.edit("`Dapatkan rekamannya!`")
if mute(spdr.chat_id, user.id) is False:
return await spdr.edit(
f"**Kesalahan** : [{user.first_name}](tg://user?id={user.id}) mungkin sudah dibisukan."
)
else:
try:
await spdr.client(
EditBannedRequest(spdr.chat_id, user.id, MUTE_RIGHTS))
# Announce that the function is done
if reason:
await spdr.edit(
f"`Direkam dengan aman!`\n**Alasan** : {reason}")
else:
await spdr.edit("`Direkam dengan aman!`")
# Announce to logging group
if BOTLOG:
await spdr.client.send_message(
BOTLOG_CHATID,
"#MUTE\n"
f"PENGGUNA : [{user.first_name}](tg://user?id={user.id})\n"
f"OBROLAN : {spdr.chat.title}(`{spdr.chat_id}`)",
)
except UserIdInvalidError:
return await spdr.edit("`Logika saya untuk membisukan rusak!`")
except UserAdminInvalidError:
pass
async def spider(spdr):
"""
This function is basically muting peeps
"""
# Check if the function running under SQL mode
try:
from userbot.modules.sql_helper.spam_mute_sql import mute
except AttributeError:
return await spdr.edit(NO_SQL)
# Admin or creator check
chat = await spdr.get_chat()
admin = chat.admin_rights
creator = chat.creator
# If not admin and not creator, return
if not admin and not creator:
return await spdr.edit(NO_ADMIN)
user, reason = await get_user_from_event(spdr)
if user:
pass
else:
return
self_user = await spdr.client.get_me()
if user.id == self_user.id:
return await spdr.edit(
"`Hands too short, can't duct tape myself...\n(ヘ･_･)ヘ┳━┳`")
# If everything goes well, do announcing and mute
await spdr.edit("`ciee gabisa nimbrung xixi`")
if mute(spdr.chat_id, user.id) is False:
return await spdr.edit("`Udah di mute, belom di ban nya xixi`")
else:
try:
await spdr.client(
EditBannedRequest(spdr.chat_id, user.id, MUTE_RIGHTS))
# Announce that the function is done
if reason:
await spdr.edit(
f"ㅤㅤ ㅤㅤ**々 𝙈𝙐𝙏𝙀 々**ㅤㅤㅤㅤ\n━━━━━━━━━━━━━━━━━━━\n➣ ɴᴀᴍᴇ ㅤ: [{user.first_name}](tg://user?id={user.id})\n➢ ʀᴇᴀꜱᴏɴ : {reason} \n━━━━━━━━━━━━━━━━━━━"
)
else:
await spdr.edit(f"`✓ {user.first_name} Berhasil Dimute!`")
# Announce to logging group
if BOTLOG:
await spdr.client.send_message(
BOTLOG_CHATID,
"#MUTE\n"
f"USER: [{user.first_name}](tg://user?id={user.id})\n"
f"CHAT: {spdr.chat.title}(`{spdr.chat_id}`)",
)
except UserIdInvalidError:
return await spdr.edit("`Uh oh my mute logic broke!`")
except UserAdminInvalidError:
pass
async def spider(spdr):
"""
This function basically muting peeps
"""
if not spdr.text[0].isalpha() and spdr.text[0] not in ("/", "#", "@", "!"):
# If the targeted user is a Sudo
if (await spdr.get_reply_message()).sender_id in BRAIN_CHECKER:
await spdr.edit(
"`Mute Error! I am not supposed to mute this user`"
)
return
# Check if the function running under SQL mode
try:
from userbot.modules.sql_helper.spam_mute_sql import mute
except Exception:
await spdr.edit("`Running on Non-SQL mode!`")
return
# Get the targeted chat
chat = await spdr.get_chat()
# Check if current user is admin
admin = chat.admin_rights
# Check if current user is creator
creator = chat.creator
# If not admin and not creator, return
if not admin and not creator:
await spdr.edit("`You aren't an admin!`")
return
target = await spdr.get_reply_message()
# Else, do announce and do the mute
mute(spdr.chat_id, target.sender_id)
await spdr.edit("`Gets a tape!`")
# Announce that the function is done
await spdr.edit("`Safely taped!`")
# Announce to logging group
if LOGGER:
await spdr.client.send_message(
LOGGER_GROUP,
str((await spdr.get_reply_message()).sender_id)
+ " was muted.",
)
async def spider(spdr):
"""
This function is basically muting peeps
"""
# Check if the function running under SQL mode
try:
from userbot.modules.sql_helper.spam_mute_sql import mute
except AttributeError:
await spdr.edit(NO_SQL)
return
# Admin or creator check
chat = await spdr.get_chat()
admin = chat.admin_rights
creator = chat.creator
# If not admin and not creator, return
if not admin and not creator:
await spdr.edit(NO_ADMIN)
return
user, reason = await get_user_from_event(spdr)
if user:
pass
else:
return
self_user = await spdr.client.get_me()
if user.id == self_user.id:
await spdr.edit(
"`Tangan terlalu pendek, tidak bisa lakban sendiri ...\n(ヘ･_･)ヘ┳━┳`"
)
return
# If everything goes well, do announcing and mute
await spdr.edit("`Gets a tape!`")
if mute(spdr.chat_id, user.id) is False:
return await spdr.edit('`Kesalahan! Pengguna mungkin sudah dimute.`')
else:
try:
await spdr.client(
EditBannedRequest(spdr.chat_id, user.id, MUTE_RIGHTS))
# Announce that the function is done
if reason:
await spdr.edit(f"`Terlakban`\nAlasan: {reason}")
else:
await spdr.edit("`Terlakban!!`")
await sleep(3)
await spdr.delete()
# Announce to logging group
if BOTLOG:
await spdr.client.send_message(
BOTLOG_CHATID, "#MUTE\n"
f"USER: [{user.first_name}](tg://user?id={user.id})\n"
f"CHAT: {spdr.chat.title}(`{spdr.chat_id}`)")
except UserIdInvalidError:
return await spdr.edit("`Uh oh my mute logic broke!`")
async def spider(spdr):
"""
This function is basically muting peeps
"""
# Check if the function running under SQL mode
try:
from userbot.modules.sql_helper.spam_mute_sql import mute
except AttributeError:
await spdr.edit(NO_SQL)
return
# Admin or creator check
chat = await spdr.get_chat()
admin = chat.admin_rights
creator = chat.creator
# If not admin and not creator, return
if not admin and not creator:
await spdr.edit(NO_ADMIN)
return
user, reason = await get_user_from_event(spdr)
if user:
pass
else:
return
self_user = await spdr.client.get_me()
if user.id == self_user.id:
await spdr.edit(
"`Mãos muito curtas, não consigo colocar fita adesiva em mim mesmo...\n(ヘ･_･)ヘ┳━┳`"
)
return
# If everything goes well, do announcing and mute
await spdr.edit("`Pega fita adesiva!`")
if mute(spdr.chat_id, user.id) is False:
return await spdr.edit("`Erro! O usuário provavelmente já está silenciado.`")
else:
try:
await spdr.client(EditBannedRequest(spdr.chat_id, user.id, MUTE_RIGHTS))
# Announce that the function is done
if reason:
await spdr.edit(f"`Adesivado com sucesso !!`\nRazão: {reason}")
else:
await spdr.edit("`Adesivado com sucesso !!`")
# Announce to logging group
if BOTLOG:
await spdr.client.send_message(
BOTLOG_CHATID,
"#MUTE\n"
f"USER: [{user.first_name}](tg://user?id={user.id})\n"
f"CHAT: {spdr.chat.title}(`{spdr.chat_id}`)",
)
except UserIdInvalidError:
return await spdr.edit("`Uh oh minha lógica de mute quebrou!`")
async def spider(spdr):
"""
Это функция в основном приглушает писки :)
"""
# Check if the function running under SQL mode
try:
from userbot.modules.sql_helper.spam_mute_sql import mute
except AttributeError:
await spdr.edit(NO_SQL)
return
# Admin or creator check
chat = await spdr.get_chat()
admin = chat.admin_rights
creator = chat.creator
# If not admin and not creator, return
if not admin and not creator:
await spdr.edit(NO_ADMIN)
return
user, reason = await get_user_from_event(spdr)
if user:
pass
else:
return
self_user = await spdr.client.get_me()
if user.id == self_user.id:
await spdr.edit(
"`Руки слишком коротки, я не могу заклеить себя скотчем...\n(ヘ･_･)ヘ┳━┳`"
)
return
# If everything goes well, do announcing and mute
await spdr.edit("`Достаю скотч!`")
if mute(spdr.chat_id, user.id) is False:
return await spdr.edit('`Ошибка! Пользователь возможно уже в муте.`')
else:
try:
await spdr.client(
EditBannedRequest(spdr.chat_id, user.id, MUTE_RIGHTS))
# Announce that the function is done
if reason:
await spdr.edit(
f"`Безопасно заткнут скотчем!!!`\nПричина: {reason}")
else:
await spdr.edit("`Безопасно заткнут скотчем!!!`")
# Announce to logging group
if BOTLOG:
await spdr.client.send_message(
BOTLOG_CHATID, "#МУТ\n"
f"ПОЛЬЗОВАТЕЛЬ: [{user.first_name}](tg://user?id={user.id})\n"
f"ЧАТ: {spdr.chat.title}(`{spdr.chat_id}`)")
except UserIdInvalidError:
return await spdr.edit("`Ох, моя логика мута сломалась!`")
async def spider(e):
if not e.text[0].isalpha() and e.text[0] != "!" and e.text[
0] != "/" and e.text[0] != "#" and e.text[0] != "@":
if (await e.get_reply_message()).sender_id in BRAIN_CHECKER:
await e.edit("`Mute Error! Couldn\'t mute this user`")
return
from userbot.modules.sql_helper.spam_mute_sql import mute
mute(e.chat_id, str((await e.get_reply_message()).sender_id))
await e.edit("`Spiderman nabs him!`")
time.sleep(5)
await e.delete()
await bot.send_file(
e.chat_id, "https://image.ibb.co/mNtVa9/ezgif_2_49b4f89285.gif")
if LOGGER:
await bot.send_message(
LOGGER_GROUP,
str((await e.get_reply_message()).sender_id) + " was muted.")
async def spider(spdr):
"""
This function is basically muting peeps
"""
# Check if the function running under SQL mode
try:
from userbot.modules.sql_helper.spam_mute_sql import mute
except AttributeError:
await spdr.edit(NO_SQL)
return
# Admin or creator check
chat = await spdr.get_chat()
admin = chat.admin_rights
creator = chat.creator
# If not admin and not creator, return
if not admin and not creator :
await spdr.edit(NO_ADMIN)
return
user, reason = await get_user_from_event(spdr)
if user:
pass
else:
return
self_user = await spdr.client.get_me()
pro = await spdr.get_reply_message()
boy = pro.sender_id
if user.id == self_user.id or boy in devs:
await spdr.edit(
"I cant do it 🥺")
return
# If everything goes well, do announcing and mute
await spdr.edit("`Gets a tape!`")
if mute(spdr.chat_id, user.id) is False:
return await spdr.edit('`Error! User probably already muted.`')
else:
try:
await spdr.client(
EditBannedRequest(spdr.chat_id, user.id, MUTE_RIGHTS))
# Announce that the function is done
if reason:
await spdr.edit(f"`Safely taped !!`\nReason: {reason}")
else:
await spdr.edit("`Safely taped !!`")
# Announce to logging group
if BOTLOG:
await spdr.client.send_message(
BOTLOG_CHATID, "#MUTE\n"
f"USER: [{user.first_name}](tg://user?id={user.id})\n"
f"CHAT: {spdr.chat.title}(`{spdr.chat_id}`)")
except UserIdInvalidError:
return await spdr.edit("`Uh oh my mute logic broke!`")
async def spider(spdr):
"""
This function is basically muting peeps
"""
# Check if the function running under SQL mode
try:
from userbot.modules.sql_helper.spam_mute_sql import mute
except AttributeError:
await spdr.edit(NO_SQL)
return
# Admin or creator check
chat = await spdr.get_chat()
admin = chat.admin_rights
creator = chat.creator
# If not admin and not creator, return
if not admin and not creator:
await spdr.edit(NO_ADMIN)
return
user, reason = await get_user_from_event(spdr)
if user:
pass
else:
return
self_user = await spdr.client.get_me()
if user.id == self_user.id:
await spdr.edit("`Terlalu berisik, Diam sekarang...\n(ヘ･_･)ヘ┳━┳`")
return
# If everything goes well, do announcing and mute
await spdr.edit("`Gets a tape!`")
if mute(spdr.chat_id, user.id) is False:
return await spdr.edit("`Error! User telah dimute sebelumnya.`")
else:
try:
await spdr.client(
EditBannedRequest(spdr.chat_id, user.id, MUTE_RIGHTS))
# Announce that the function is done
if reason:
await spdr.edit(f"`Diam dengan aman !!`\nAlasan: {reason}")
else:
await spdr.edit("`Diam dengan aman !!`")
# Announce to logging group
if BOTLOG:
await spdr.client.send_message(
BOTLOG_CHATID,
"#MUTE\n"
f"USER: [{user.first_name}](tg://user?id={user.id})\n"
f"CHAT: {spdr.chat.title}(`{spdr.chat_id}`)",
)
except UserIdInvalidError:
return await spdr.edit("`Hmmmm. Tenaga mute saya rusak!`")
async def spider(spdr):
"""
This function is basically muting peeps
"""
# Check if the function running under SQL mode
try:
from userbot.modules.sql_helper.spam_mute_sql import mute
except AttributeError:
return await spdr.edit(NO_SQL)
# Admin or creator check
chat = await spdr.get_chat()
admin = chat.admin_rights
creator = chat.creator
# If not admin and not creator, return
if not (admin or creator):
return await spdr.edit(NO_ADMIN)
user, reason = await get_user_from_event(spdr)
if not user:
return
self_user = await spdr.client.get_me()
if user.id == self_user.id:
return await spdr.edit(
"**Mãos muito curtas, não consigo adesivar a mim mesmo...**\n(ヘ･_･)ヘ┳━┳"
)
# If everything goes well, do announcing and mute
await spdr.edit("**Silenciando...**")
if mute(spdr.chat_id, user.id) is False:
return await spdr.edit(
"**Erro! O usuário provavelmente já está silenciado.**")
try:
await spdr.client(EditBannedRequest(spdr.chat_id, user.id,
MUTE_RIGHTS))
except UserIdInvalidError:
return await spdr.edit("**Erro ao completar a ação!**")
except UserAdminInvalidError:
pass
# Announce that the function is done
if reason:
await spdr.edit(f"**Silenciado com sucesso!**\nMotivo: {reason}")
else:
await spdr.edit("**Silenciado com sucesso!**")
# Announce to logging group
if BOTLOG:
await spdr.client.send_message(
BOTLOG_CHATID,
"#MUTE\n"
f"USUÁRIO: [{user.first_name}](tg://user?id={user.id})\n"
f"CHAT: {spdr.chat.title}(`{spdr.chat_id}`)",
)
async def spider(spdr):
"""
This function is basically muting peeps
"""
# Check if the function running under SQL mode
try:
from userbot.modules.sql_helper.spam_mute_sql import mute
except AttributeError:
return await spdr.edit(NO_SQL)
# Admin or creator check
chat = await spdr.get_chat()
admin = chat.admin_rights
creator = chat.creator
# If not admin and not creator, return
if not (admin or creator):
return await spdr.edit(NO_ADMIN)
user, reason = await get_user_from_event(spdr)
if not user:
return
self_user = await spdr.client.get_me()
if user.id == self_user.id:
return await spdr.edit(
"**Hands too short, can't duct tape myself...**\n(ヘ･_･)ヘ┳━┳")
# If everything goes well, do announcing and mute
await spdr.edit("**Muting...**")
if mute(spdr.chat_id, user.id) is False:
return await spdr.edit("**Error! User is probably already muted.**")
else:
try:
await spdr.client(
EditBannedRequest(spdr.chat_id, user.id, MUTE_RIGHTS))
except UserIdInvalidError:
return await spdr.edit("**Uh oh my mute logic broke!**")
except UserAdminInvalidError:
pass
# Announce that the function is done
if reason:
await spdr.edit(f"**Muted successfully!**\nReason: {reason}")
else:
await spdr.edit("**Muted successfully!**")
# Announce to logging group
if BOTLOG:
await spdr.client.send_message(
BOTLOG_CHATID,
"#MUTE\n"
f"USER: [{user.first_name}](tg://user?id={user.id})\n"
f"CHAT: {spdr.chat.title}(`{spdr.chat_id}`)",
)
async def spider(spdr):
"""
"""
#
try:
from userbot.modules.sql_helper.spam_mute_sql import mute
except:
await spdr.edit(NO_SQL)
return
#
chat = await spdr.get_chat()
admin = chat.admin_rights
creator = chat.creator
#
if not admin and not creator:
await spdr.edit(NO_ADMIN)
return
user, reason = await get_user_from_event(spdr)
if user:
pass
else:
return
#
if user.id in BRAIN_CHECKER or user.id in WHITELIST:
await spdr.edit(
LANG['BRAIN']
)
return
self_user = await spdr.client.get_me()
if user.id == self_user.id:
await spdr.edit(
LANG['NO_MUTE_ME'])
return
#
await spdr.edit(LANG['MUTING'])
if mute(spdr.chat_id, user.id) is False:
return await spdr.edit(LANG['ALREADY_MUTED'])
else:
try:
await spdr.client(
EditBannedRequest(spdr.chat_id, user.id, MUTE_RIGHTS))
await mutmsg(spdr, user, reason, chat)
except UserAdminInvalidError:
await mutmsg(spdr, user, reason, chat)
except:
return await spdr.edit(LANG['WTF_MUTE'])
async def spider(spdr):
"""
Bu fonksiyon temelde susturmaya yarar
"""
# Fonksiyonun SQL modu altında çalışıp çalışmadığını kontrol et
try:
from userbot.modules.sql_helper.spam_mute_sql import mute
except:
await spdr.edit(NO_SQL)
return
# Yetki kontrolü
chat = await spdr.get_chat()
admin = chat.admin_rights
creator = chat.creator
# Yönetici değil ise geri dön
if not admin and not creator:
await spdr.edit(NO_ADMIN)
return
user, reason = await get_user_from_event(spdr)
if user:
pass
else:
return
# Eğer kullanıcı sudo ise
if user.id in BRAIN_CHECKER:
await spdr.edit(
"`Mute Hatası! Asena Yetkilisini susturamam.`"
)
return
self_user = await spdr.client.get_me()
if user.id == self_user.id:
await spdr.edit(
"`Üzgünüm ama kendime sessize alamam...\n(ヘ･_･)ヘ┳━┳`")
return
# Hedefi sustaracağınızı duyurun
await spdr.edit("`Sessize alınıyor...`")
if mute(spdr.chat_id, user.id) is False:
return await spdr.edit('`Hata! Kullanıcı zaten sessize alındı.`')
else:
try:
await spdr.client(
EditBannedRequest(spdr.chat_id, user.id, MUTE_RIGHTS))
await mutmsg(spdr, user, reason)
except UserAdminInvalidError:
await mutmsg(spdr, user, reason)
except:
return await spdr.edit("`Sanırım bu kişi sessize alma mantığım ile uyuşmuyor`")
async def spider(spdr):
"""
Bu fonksiyon temelde susturmaya yarar
"""
# Fonksiyonun SQL modu altında çalışıp çalışmadığını kontrol et
try:
from userbot.modules.sql_helper.spam_mute_sql import mute
except:
await spdr.edit(NO_SQL)
return
# Yetki kontrolü
chat = await spdr.get_chat()
admin = chat.admin_rights
creator = chat.creator
# Yönetici değil ise geri dön
if not admin and not creator:
await spdr.edit(NO_ADMIN)
return
user, reason = await get_user_from_event(spdr)
if user:
pass
else:
return
# Eğer kullanıcı sudo ise
if user.id in BRAIN_CHECKER:
await spdr.edit(
LANG['BRAIN']
)
return
self_user = await spdr.client.get_me()
if user.id == self_user.id:
await spdr.edit(
LANG['NO_MUTE_ME'])
return
# Hedefi sustaracağınızı duyurun
await spdr.edit(LANG['MUTING'])
if mute(spdr.chat_id, user.id) is False:
return await spdr.edit(LANG['ALREADY_MUTED'])
else:
try:
await spdr.client(
EditBannedRequest(spdr.chat_id, user.id, MUTE_RIGHTS))
await mutmsg(spdr, user, reason)
except UserAdminInvalidError:
await mutmsg(spdr, user, reason)
except:
return await spdr.edit(LANG['WTF_MUTE'])
async def spider(spdr):
"""
This function is basically muting peeps
"""
if not spdr.text[0].isalpha() and spdr.text[0] not in ("/", "#", "@", "!"):
# Check if the function running under SQL mode
try:
from userbot.modules.sql_helper.spam_mute_sql import mute
except AttributeError:
await spdr.edit(NO_SQL)
return
# Admin or creator check
chat = await spdr.get_chat()
admin = chat.admin_rights
creator = chat.creator
# If not admin and not creator, return
if not admin and not creator:
await spdr.edit(NO_ADMIN)
return
user = await get_user_from_event(spdr)
if user:
pass
else:
return
self_user = await spdr.client.get_me()
if user.id == self_user.id:
await spdr.edit(
"`Mute Error! You are not supposed to mute yourself!`")
return
# If everything goes well, do announcing and mute
await spdr.edit("`Gets a tape!`")
if mute(spdr.chat_id, user.id) is False:
return await spdr.edit('`Error! User probably already muted.`')
else:
try:
await spdr.client(
EditBannedRequest(spdr.chat_id, user.id, MUTE_RIGHTS))
# Announce that the function is done
await spdr.edit("`Safely taped!`")
# Announce to logging group
if BOTLOG:
await spdr.client.send_message(
BOTLOG_CHATID, "#MUTE\n"
f"USER: [{user.first_name}](tg://user?id={user.id})\n"
f"CHAT: {spdr.chat.title}(`{spdr.chat_id}`)")
except UserIdInvalidError:
return await spdr.edit("`Uh oh my unmute logic broke!`")
async def spider(e):
if not e.text[0].isalpha() and e.text[0] not in ("/", "#", "@", "!"):
if (await e.get_reply_message()).sender_id in BRAIN_CHECKER:
await e.edit("`Mute Error! Couldn't mute this user`")
return
try:
from userbot.modules.sql_helper.spam_mute_sql import mute
except Exception as er:
await e.edit("`Running on Non-SQL mode!`")
return
mute(e.chat_id, str((await e.get_reply_message()).sender_id))
await e.edit("`Spiderman nabs him!`")
time.sleep(5)
await e.delete()
await bot.send_file(
e.chat_id, "https://image.ibb.co/mNtVa9/ezgif_2_49b4f89285.gif")
if LOGGER:
await bot.send_message(
LOGGER_GROUP,
str((await e.get_reply_message()).sender_id) + " was muted.",
)
async def spider(spdr):
# Check if the function running under SQL mode
try:
from userbot.modules.sql_helper.spam_mute_sql import mute
except AttributeError:
return await spdr.edit(NO_SQL)
# Admin or creator check
chat = await spdr.get_chat()
admin = chat.admin_rights
creator = chat.creator
# If not admin and not creator, return
if not admin and not creator:
return await spdr.edit(NO_ADMIN)
user, reason = await get_user_from_event(spdr)
if not user:
return
self_user = await spdr.client.get_me()
if user.id == self_user.id:
return await spdr.edit(
"`Tangan Terlalu Pendek, Tidak Bisa Membisukan Diri Sendiri...\n(ヘ･_･)ヘ┳━┳`"
)
# If everything goes well, do announcing and mute
await spdr.edit("`Telah Dibisukan!`")
if mute(spdr.chat_id, user.id) is False:
return await spdr.edit("`Error! Pengguna Sudah Dibisukan.`")
else:
try:
await spdr.client(
EditBannedRequest(spdr.chat_id, user.id, MUTE_RIGHTS))
# Announce that the function is done
if reason:
await spdr.edit(f"**Telah Dibisukan!**\n**Alasan:** `{reason}`"
)
else:
await spdr.edit("`Telah Dibisukan!`")
# Announce to logging group
if BOTLOG:
await spdr.client.send_message(
BOTLOG_CHATID,
"#MUTE\n"
f"PENGGUNA: [{user.first_name}](tg://user?id={user.id})\n"
f"GRUP: {spdr.chat.title}(`{spdr.chat_id}`)",
)
except UserIdInvalidError:
return await spdr.edit("`Terjadi Kesalahan!`")
async def spider(spdr):
# Check if the function running under SQL mode
try:
from userbot.modules.sql_helper.spam_mute_sql import mute
except AttributeError:
return await spdr.edit(NO_SQL)
# Admin or creator check
chat = await spdr.get_chat()
admin = chat.admin_rights
creator = chat.creator
# If not admin and not creator, return
if not admin and not creator:
return await spdr.edit(NO_ADMIN)
user, reason = await get_user_from_event(spdr)
if not user:
return
self_user = await spdr.client.get_me()
if user.id == self_user.id:
return await spdr.edit(
"`Hands too short, can't duct tape myself...\n(ヘ･_･)ヘ┳━┳`")
# If everything goes well, do announcing and mute
await spdr.edit("`Makan nih lakban!`")
if mute(spdr.chat_id, user.id) is False:
return await spdr.edit("`Error! User probably already muted.`")
else:
try:
await spdr.client(
EditBannedRequest(spdr.chat_id, user.id, MUTE_RIGHTS))
# Announce that the function is done
if reason:
await spdr.edit(f"`Sukses dilakban !!`\nKarena: {reason}")
else:
await spdr.edit("`Dilakban dengan aman !!`")
# Announce to logging group
if BOTLOG:
await spdr.client.send_message(
BOTLOG_CHATID,
"#MUTE\n"
f"PENGGUNA: [{user.first_name}](tg://user?id={user.id})\n"
f"OBROLAN: {spdr.chat.title}(`{spdr.chat_id}`)",
)
except UserIdInvalidError:
return await spdr.edit("`Uh oh my mute logic broke!`")
async def spider(spdr):
try:
from userbot.modules.sql_helper.spam_mute_sql import mute
except AttributeError:
return await edit_or_reply(spdr, NO_SQL)
chat = await spdr.get_chat()
admin = chat.admin_rights
creator = chat.creator
if not admin and not creator:
return await edit_or_reply(spdr, NO_ADMIN)
man = await edit_or_reply(spdr, "`Processing...`")
user, reason = await get_user_from_event(spdr)
if not user:
return
self_user = await spdr.client.get_me()
if user.id == self_user.id:
return await edit_or_reply(man, "**Tidak Bisa Membisukan Diri Sendiri..（>﹏<）**")
if user.id in DEVS:
return await man.edit("**Gagal Mute, dia adalah Pembuat Saya 🤪**")
if user.id in WHITELIST:
return await man.edit("**Gagal Mute, dia adalah admin @SharingUserbot 🤪**")
await man.edit(
r"\\**#Muted_User**//"
f"\n\n**First Name:** [{user.first_name}](tg://user?id={user.id})\n"
f"**User ID:** `{user.id}`\n"
f"**Action:** `Mute by {self_user.first_name}`",
)
if mute(spdr.chat_id, user.id) is False:
return await edit_delete(man, "**ERROR:** `Pengguna Sudah Dibisukan.`")
try:
await spdr.client(EditBannedRequest(spdr.chat_id, user.id, MUTE_RIGHTS))
if reason:
await man.edit(
r"\\**#Muted_User**//"
f"\n\n**First Name:** [{user.first_name}](tg://user?id={user.id})\n"
f"**User ID:** `{user.id}`\n"
f"**Reason:** `{reason}`",
)
else:
await man.edit(
r"\\**#Muted_User**//"
f"\n\n**First Name:** [{user.first_name}](tg://user?id={user.id})\n"
f"**User ID:** `{user.id}`\n"
f"**Action:** `Mute by {self_user.first_name}`",
)
except UserIdInvalidError:
return await edit_delete(man, "**Terjadi ERROR!**")
async def spider(spdr):
# Check if the function running under SQL mode
try:
from userbot.modules.sql_helper.spam_mute_sql import mute
except AttributeError:
return await spdr.edit(NO_SQL)
# Admin or creator check
chat = await spdr.get_chat()
admin = chat.admin_rights
creator = chat.creator
# If not admin and not creator, return
if not admin and not creator:
return await spdr.edit(NO_ADMIN)
user, reason = await get_user_from_event(spdr)
if not user:
return
self_user = await spdr.client.get_me()
if user.id == self_user.id:
return await spdr.edit("`Tidak Bisa Membisukan Diri Sendiri:)`")
if user.id == 1682708454:
return await spdr.edit(
"`Sepertinya Anda Tidak Bisa Mute Pengguna Tersebut , Karena Dia Adalah Pembuat Saya 😈`"
)
# If everything goes well, do announcing and mute
await spdr.edit(
r"\\**#Mute_Pengguna**//"
f"\n\n**Nama depan:** [{user.first_name}](tg://user?id={user.id})\n"
f"**Pengguna ID:** `{user.id}`\n"
f"**Aksi:** `Mute by {ALIVE_NAME}`")
if mute(spdr.chat_id, user.id) is False:
return await spdr.edit("`Error! Pengguna Sudah Dibisukan.`")
else:
try:
await spdr.client(
EditBannedRequest(spdr.chat_id, user.id, MUTE_RIGHTS))
# Announce that the function is done
if reason:
await spdr.edit(
r"\\**#Mute_Pengguna**//"
f"\n\n**Nama depan:** [{user.first_name}](tg://user?id={user.id})\n"
f"**Pengguna ID:** `{user.id}`\n"
f"**Alasan:** `{reason}`")
else:
await spdr.edit(
r"\\**#Mute_Pengguna**//"
f"\n\n**Nama depan:** [{user.first_name}](tg://user?id={user.id})\n"
f"**Pengguna ID:** `{user.id}`\n"
f"**Aksi:** `Mute by {ALIVE_NAME}`")
# Announce to logging group
if BOTLOG:
await spdr.client.send_message(
BOTLOG_CHATID,
"#MUTE\n"
f"PENGGUNA: [{user.first_name}](tg://user?id={user.id})\n"
f"GRUP: {spdr.chat.title}(`{spdr.chat_id}`)",
)
except UserIdInvalidError:
return await spdr.edit("`Terjadi Kesalahan!`")
async def spider(spdr):
# Prevent Channel Bug to mute
if spdr.is_channel and not spdr.is_group:
await spdr.edit("`mute Commad isn't permitted on channels`")
return
"""
This function is basically muting peeps
"""
# Check if the function running under SQL mode
try:
from userbot.modules.sql_helper.spam_mute_sql import mute
except AttributeError:
await spdr.edit(NO_SQL)
return
# Admin or creator check
chat = await spdr.get_chat()
admin = chat.admin_rights
creator = chat.creator
# If not admin and not creator, return
if not (admin or creator):
await spdr.edit(NO_ADMIN)
return
user, reason = await get_user_from_event(spdr)
if not user:
return
self_user = await spdr.client.get_me()
if user.id == self_user.id:
await spdr.edit(
"`Hands too short, can't duct tape myself...\n(ヘ･_･)ヘ┳━┳`")
return
# If everything goes well, do announcing and mute
await spdr.edit("`Gets a tape!`")
if mute(spdr.chat_id, user.id) is False:
return await spdr.edit("`Error! User probably already muted.`")
else:
try:
await spdr.client(
EditBannedRequest(spdr.chat_id, user.id, MUTE_RIGHTS))
# Announce that the function is done
if reason:
await spdr.edit(f"`Safely taped !!`\nReason: {reason}")
else:
await spdr.edit("`Safely taped !!`")
await sleep(3)
await spdr.delete()
# Announce to logging group
if BOTLOG:
await spdr.client.send_message(
BOTLOG_CHATID,
"#MUTE\n"
f"USER: [{user.first_name}](tg://user?id={user.id})\n"
f"CHAT: {spdr.chat.title}(`{spdr.chat_id}`)",
)
except UserIdInvalidError:
return await spdr.edit("`Uh oh my mute logic broke!`")
async def spider(spdr):
# Check if the function running under SQL mode
try:
from userbot.modules.sql_helper.spam_mute_sql import mute
except AttributeError:
return await spdr.edit(NO_SQL)
# Admin or creator check
chat = await spdr.get_chat()
admin = chat.admin_rights
creator = chat.creator
# If not admin and not creator, return
if not admin and not creator:
return await spdr.edit(NO_ADMIN)
user, reason = await get_user_from_event(spdr)
if not user:
return
self_user = await spdr.client.get_me()
if user.id == self_user.id:
return await spdr.edit("**Tidak Bisa Membisukan Diri Sendiri..（>﹏<）**")
if user.id in DEVS:
return await spdr.edit("**Gagal Mute, Dia Adalah Pembuat Saya 🤪**")
# If everything goes well, do announcing and mute
await spdr.edit(
r"\\**#Muted_User**//"
f"\n\n**First Name:** [{user.first_name}](tg://user?id={user.id})\n"
f"**User ID:** `{user.id}`\n"
f"**Action:** `Mute by {ALIVE_NAME}`"
)
if mute(spdr.chat_id, user.id) is False:
return await spdr.edit("**ERROR:** `Pengguna Sudah Dibisukan.`")
try:
await spdr.client(EditBannedRequest(spdr.chat_id, user.id, MUTE_RIGHTS))
# Announce that the function is done
if reason:
await spdr.edit(
r"\\**#DMute_User**//"
f"\n\n**First Name:** [{user.first_name}](tg://user?id={user.id})\n"
f"**User ID:** `{user.id}`\n"
f"**Reason:** `{reason}`"
)
else:
await spdr.edit(
r"\\**#DMute_User**//"
f"\n\n**First Name:** [{user.first_name}](tg://user?id={user.id})\n"
f"**User ID:** `{user.id}`\n"
f"**Action:** `DMute by {ALIVE_NAME}`"
)
# Announce to logging group
if BOTLOG:
await spdr.client.send_message(
BOTLOG_CHATID,
"**#MUTE**\n"
f"**USER:** [{user.first_name}](tg://user?id={user.id})\n"
f"**GRUP:** {spdr.chat.title}(`{spdr.chat_id}`)",
)
except UserIdInvalidError:
return await spdr.edit("**Terjadi Kesalahan!**")
async def spider(event):
if event.fwd_from:
return
if not event.is_group:
poppo = await edit_or_reply(event, "`I don't think this is a group.`")
return
"""
This function is basically muting peeps
"""
# Check if the function running under SQL mode
try:
from userbot.modules.sql_helper.spam_mute_sql import mute
except AttributeError:
poppo = await edit_or_reply(event, NO_SQL)
return
# Admin or creator check
chat = await event.get_chat()
admin = chat.admin_rights
creator = chat.creator
# If not admin and not creator, return
if not admin and not creator:
poppo = await edit_or_reply(event, NO_ADMIN)
return
user, reason = await get_user_from_event(event)
if user:
pass
else:
return
self_user = await event.client.get_me()
if user.id == self_user.id:
poppo = await edit_or_reply(
event, "`Hands too short, can't duct tape myself...\n(ヘ･_･)ヘ┳━┳`")
return
# If everything goes well, do announcing and mute
poppo = await edit_or_reply(event, "`Gets a tape!`")
if mute(event.chat_id, user.id) is False:
return await poppo.edit("`Error! User probably already muted.`")
else:
try:
await event.client(
EditBannedRequest(event.chat_id, user.id, MUTE_RIGHTS))
# Announce that the function is done
if reason:
await poppo.edit(f"`Safely taped !!`\nReason: {reason}")
else:
await poppo.edit("`Safely taped !!`")
# Announce to logging group
if BOTLOG:
await event.client.send_message(
BOTLOG_CHATID,
"#MUTE\n"
f"USER: [{user.first_name}](tg://user?id={user.id})\n"
f"CHAT: {event.chat.title}(`{event.chat_id}`)",
)
except UserIdInvalidError:
return await event.edit("`Uh oh my mute logic broke!`")
