"*Ejemplo:* `/tr en-es` Para traducir del inglés al español\n\n"
"Para ver la lista de códigos de idioma puedes hacer click [aquí](http://t.me/CrimsonMeguRobot?start=ghelp_traductor).",
parse_mode="markdown",
disable_web_page_preview=True,
)
except ValueError:
update.effective_message.reply_text(
"No se encontró el idioma deseado!")
else:
return
__help__ = """
• `/tr` o `/tl` <código de idioma> Como respuesta a un mensaje largo. (Traducción predeterminada en español)
*Ejemplos:*
`/tr en`: Traduce algo al inglés.
`/tr en-es`: Traduce del inglés al español.
*Lista de códigos de idioma:*\n\n`af`,`am`,`ar`,`az`,`be`,`bg`,`bn`,`bs`,`ca`,`ceb`,`co`,`cs`,`cy`,`da`,`de`,`el`,`en`,`eo`,`es`,`et`,`eu`,`fa`,`fi`,`fr`,`fy`,`ga`,`gd`,`gl`,`gu`,`ha`,`haw`,`hi`,`hmn`,`hr`,`ht`,`hu`,`hy`,`id`,`ig`,`is`,`it`,`iw`,`ja`,`jw`,`ka`,`kk`,`km`,`kn`,`ko`,`ku`,`ky`,`la`,`lb`,`lo`,`lt`,`lv`,`mg`,`mi`,`mk`,`ml`,`mn`,`mr`,`ms`,`mt`,`my`,`ne`,`nl`,`no`,`ny`,`pa`,`pl`,`ps`,`pt`,`ro`,`ru`,`sd`,`si`,`sk`,`sl`,`sm`,`sn`,`so`,`sq`,`sr`,`st`,`su`,`sv`,`sw`,`ta`,`te`,`tg`,`th`,`tl`,`tr`,`uk`,`ur`,`uz`,`vi`,`xh`,`yi`,`yo`,`zh`,`zh_CN`,`zh_TW`,`zu`
"""
TRANSLATE_HANDLER = DisableAbleCommandHandler(["tr", "tl"],
totranslate,
run_async=True)
dispatcher.add_handler(TRANSLATE_HANDLER)
__mod_name__ = "Traductor"
__command_list__ = ["tr", "tl"]
__handlers__ = [TRANSLATE_HANDLER]
f"\n-{event.from_id} ({event.chat_id}) : {event.text}")
else:
with open("updates.txt", "w+") as f:
f.write(
f"- {event.from_id} ({event.chat_id}) : {event.text} | {datetime.datetime.now()}"
)
support_chat = os.getenv("SUPPORT_CHAT")
@dev_plus
def logs(update: Update, context: CallbackContext):
user = update.effective_user
msg = update.effective_message
with open("log.txt", "rb") as f:
context.bot.send_document(document=f, filename=f.name, chat_id=user.id)
msg.reply_text("[Logs enviados](tg://user?id={})".format(context.bot.id),
parse_mode=ParseMode.MARKDOWN)
LOG_HANDLER = CommandHandler("logs", logs, run_async=True)
dispatcher.add_handler(LOG_HANDLER)
DEBUG_HANDLER = CommandHandler("debug", debug, run_async=True)
dispatcher.add_handler(DEBUG_HANDLER)
__mod_name__ = "Debug"
__command_list__ = ["debug"]
__handlers__ = [DEBUG_HANDLER]
*Nota:* Los nombres de las notas no distinguen entre mayúsculas y minúsculas y se convierten automáticamente a minúsculas antes de minúsculas
"""
__mod_name__ = "Notas"
GET_HANDLER = CommandHandler("get", cmd_get, run_async=True)
HASH_GET_HANDLER = MessageHandler(Filters.regex(r"^#[^\s]+"),
hash_get,
run_async=True)
SAVE_HANDLER = CommandHandler("save", save, run_async=True)
DELETE_HANDLER = CommandHandler("clear", clear, run_async=True)
LIST_HANDLER = DisableAbleCommandHandler(["notes", "saved"],
list_notes,
admin_ok=True,
run_async=True)
CLEARALL = DisableAbleCommandHandler("removeallnotes", clearall)
CLEARALL_BTN = CallbackQueryHandler(clearall_btn, pattern=r"notes_.*")
dispatcher.add_handler(GET_HANDLER)
dispatcher.add_handler(SAVE_HANDLER)
dispatcher.add_handler(LIST_HANDLER)
dispatcher.add_handler(DELETE_HANDLER)
dispatcher.add_handler(HASH_GET_HANDLER)
dispatcher.add_handler(CLEARALL)
dispatcher.add_handler(CLEARALL_BTN)
__command_list__ = ["get", "save", "clear", "notes", "saved", "removeallnotes"]
"<b>Tiempo tomado:</b> <code>{}</code>\n"
"<b>Tiempo en servicio:</b> <code>{}</code>".format(
telegram_ping, uptime))
update.effective_message.reply_text(reply_msg, parse_mode=ParseMode.HTML)
def pingall(update: Update, context: CallbackContext):
to_ping = ["Kaizoku", "Kayo", "Telegram", "Jikan"]
pinged_list = ping_func(to_ping)
pinged_list.insert(2, "")
uptime = get_readable_time((time.time() - StartTime))
reply_msg = "⏱Resultados de ping:\n"
reply_msg += "\n".join(pinged_list)
reply_msg += "\n<b>Tiempo en servicio:</b> <code>{}</code>".format(uptime)
update.effective_message.reply_text(reply_msg,
parse_mode=ParseMode.HTML,
disable_web_page_preview=True)
PING_HANDLER = DisableAbleCommandHandler("ping", ping, run_async=True)
PINGALL_HANDLER = DisableAbleCommandHandler("pingall", pingall, run_async=True)
dispatcher.add_handler(PING_HANDLER)
dispatcher.add_handler(PINGALL_HANDLER)
__command_list__ = ["ping", "pingall"]
__handlers__ = [PING_HANDLER, PINGALL_HANDLER]
•`/allowconnect <yes/no>`: Permite que un usuario se conecte a un grupo
"""
CONNECT_CHAT_HANDLER = CommandHandler("connect",
connect_chat,
pass_args=True,
run_async=True)
CONNECTION_CHAT_HANDLER = CommandHandler("connection",
connection_chat,
run_async=True)
DISCONNECT_CHAT_HANDLER = CommandHandler("disconnect",
disconnect_chat,
run_async=True)
ALLOW_CONNECTIONS_HANDLER = CommandHandler("allowconnect",
allow_connections,
pass_args=True,
run_async=True)
HELP_CONNECT_CHAT_HANDLER = CommandHandler("helpconnect",
help_connect_chat,
run_async=True)
CONNECT_BTN_HANDLER = CallbackQueryHandler(connect_button,
pattern=r"connect",
run_async=True)
dispatcher.add_handler(CONNECT_CHAT_HANDLER)
dispatcher.add_handler(CONNECTION_CHAT_HANDLER)
dispatcher.add_handler(DISCONNECT_CHAT_HANDLER)
dispatcher.add_handler(ALLOW_CONNECTIONS_HANDLER)
dispatcher.add_handler(HELP_CONNECT_CHAT_HANDLER)
dispatcher.add_handler(CONNECT_BTN_HANDLER)
is_blacklisted = sql.is_user_blacklisted(user_id)
text = "<b>Lista Negra:</b> <code>{}</code>"
if user_id in [777000, 1087968824]:
return ""
if user_id == dispatcher.bot.id:
return ""
if int(user_id) in SUDO_USERS + FROG_USERS + WHITELIST_USERS:
return ""
if is_blacklisted:
text = text.format("Si")
reason = sql.get_reason(user_id)
if reason:
text += f"\nRazón: <code>{reason}</code>"
else:
text = text.format("No")
return text
BL_HANDLER = CommandHandler("ignore", bl_user, run_async=True)
UNBL_HANDLER = CommandHandler("notice", unbl_user, run_async=True)
BLUSERS_HANDLER = CommandHandler("ignoredlist", bl_users, run_async=True)
dispatcher.add_handler(BL_HANDLER)
dispatcher.add_handler(UNBL_HANDLER)
dispatcher.add_handler(BLUSERS_HANDLER)
__mod_name__ = "BlackList de Usuarios"
__handlers__ = [BL_HANDLER, UNBL_HANDLER, BLUSERS_HANDLER]
•`/upcoming`*: * Devuelve una lista de nuevos animes en las próximas temporadas.
•`/airing <anime>`*:* Devuelve información de emisión de anime.
•`/whatanime`*:* Busca un anime respondiendo a un GIF, vídeo o imagen de una captura de un capítulo del Anime.
"""
AIRING_HANDLER = DisableAbleCommandHandler("airing", airing, run_async=True)
ANIME_HANDLER = DisableAbleCommandHandler("anime", anime, run_async=True)
CHARACTER_HANDLER = DisableAbleCommandHandler("character",
character,
run_async=True)
MANGA_HANDLER = DisableAbleCommandHandler("manga", manga, run_async=True)
UPCOMING_HANDLER = DisableAbleCommandHandler("upcoming",
upcoming,
run_async=True)
dispatcher.add_handler(ANIME_HANDLER)
dispatcher.add_handler(CHARACTER_HANDLER)
dispatcher.add_handler(MANGA_HANDLER)
dispatcher.add_handler(AIRING_HANDLER)
dispatcher.add_handler(UPCOMING_HANDLER)
__mod_name__ = "Anime"
__command_list__ = [
"anime",
"manga",
"character",
"upcoming",
"airing",
]
__handlers__ = [
ANIME_HANDLER,
CLASSIC_HANDLER = CommandHandler("classic", classic, run_async=True)
KUNI_HANDLER = CommandHandler("kuni", kuni, run_async=True)
WAIFU_HANDLER = CommandHandler("waifu", waifu, run_async=True)
LEWD_HANDLER = CommandHandler("lewd", lewd, run_async=True)
KISS_HANDLER = CommandHandler("kiss", kiss, run_async=True)
FEMDOM_HANDLER = CommandHandler("femdom", femdom, run_async=True)
CUDDLE_HANDLER = CommandHandler("hug", hug, run_async=True)
EROK_HANDLER = CommandHandler("erok", erok, run_async=True)
FOXGIRL_HANDLER = CommandHandler("foxgirl", foxgirl, run_async=True)
TITSGIF_HANDLER = CommandHandler("titsgif", titsgif, run_async=True)
ERO_HANDLER = CommandHandler("ero", ero, run_async=True)
SMUG_HANDLER = CommandHandler("smug", smug, run_async=True)
BAKA_HANDLER = CommandHandler("baka", baka, run_async=True)
DVA_HANDLER = CommandHandler("dva", dva, run_async=True)
dispatcher.add_handler(ADD_NSFW_HANDLER)
dispatcher.add_handler(REMOVE_NSFW_HANDLER)
dispatcher.add_handler(LIST_NSFW_CHATS_HANDLER)
dispatcher.add_handler(LEWDKEMO_HANDLER)
dispatcher.add_handler(NEKO_HANDLER)
dispatcher.add_handler(FEET_HANDLER)
dispatcher.add_handler(YURI_HANDLER)
dispatcher.add_handler(TRAP_HANDLER)
dispatcher.add_handler(FUTANARI_HANDLER)
dispatcher.add_handler(HOLOLEWD_HANDLER)
dispatcher.add_handler(SOLOGIF_HANDLER)
dispatcher.add_handler(CUMGIF_HANDLER)
dispatcher.add_handler(EROKEMO_HANDLER)
dispatcher.add_handler(LESBIAN_HANDLER)
dispatcher.add_handler(LEWDK_HANDLER)
dispatcher.add_handler(NGIF_HANDLER)
import requests
from MeguRobot import dispatcher
from MeguRobot.modules.disable import DisableAbleCommandHandler
from telegram import ParseMode, Update
from telegram.ext import CallbackContext
def ud(update: Update, context: CallbackContext):
message = update.effective_message
text = message.text[len("/ud "):]
results = requests.get(
f"https://api.urbandictionary.com/v0/define?term={text}").json()
try:
reply_text = f'*{text}*\n\n{results["list"][0]["definition"]}\n\n_{results["list"][0]["example"]}_'
except:
reply_text = "Sin resultados."
message.reply_text(reply_text, parse_mode=ParseMode.MARKDOWN)
UD_HANDLER = DisableAbleCommandHandler(["ud"], ud, run_async=True)
dispatcher.add_handler(UD_HANDLER)
__command_list__ = ["ud"]
__handlers__ = [UD_HANDLER]
)
def list_errors(update: Update, context: CallbackContext):
if update.effective_user.id not in DEV_USERS:
return
e = {
k: v
for k, v in sorted(
errors.items(), key=lambda item: item[1], reverse=True)
}
msg = "<b>Lista de errores:</b>\n"
for x in e:
msg += f"• <code>{x}:</code> <b>{e[x]}</b> #{x.identifier}\n"
msg += f"{len(errors)} errores han ocurrido desde el inicio del servicio."
if len(msg) > 4096:
with open("errors_msg.txt", "w+") as f:
f.write(msg)
context.bot.send_document(
update.effective_chat.id,
open("errors_msg.txt", "rb"),
caption=f"Han ocurrido demasiados errores...",
parse_mode="html",
)
return
update.effective_message.reply_text(msg, parse_mode="html")
dispatcher.add_error_handler(error_callback)
dispatcher.add_handler(CommandHandler("errors", list_errors))
*Reaccionar:*
•`/react`: Reacciona con una reacción aleatoria
*Urban Dictonary(ENG):*
•`/ud <palabra>` : Escriba la palabra o expresión que desea utilizar para la búsqueda
* Wikipedia: *
•`/wiki <query>`: Busca en Wikipedia
*Convertidor de moneda:*
•`/cash`: Convertidor de moneda
*Ejemplo:*
`/cash 1 USD INR`
O
`/cash 1 usd inr`
*Salida:* `1.0 USD = 75.505 INR`
"""
SAY_HANDLER = DisableAbleCommandHandler("say",
say,
filters=Filters.chat_type.groups,
run_async=True)
MD_HELP_HANDLER = CommandHandler("markdownhelp", markdown_help, run_async=True)
dispatcher.add_handler(SAY_HANDLER)
dispatcher.add_handler(MD_HELP_HANDLER)
__mod_name__ = "Extras"
__command_list__ = ["say"]
__handlers__ = [
SAY_HANDLER,
MD_HELP_HANDLER,
]
for artist, song in track_dict.items():
rep += f"🎧 <code>{artist} - {song}</code>\n"
last_user = (requests.get(
f"{base_url}?method=user.getinfo&user={username}&api_key={LASTFM_API_KEY}&format=json"
).json().get("user"))
scrobbles = last_user.get("playcount")
rep += f"\n(<code>{scrobbles}</code> scrobbles hasta ahora)"
msg.reply_text(rep, parse_mode=ParseMode.HTML)
__help__ = """
*Comandos disponibles:*
•`/setuser <nombre de usuario>`: Establece tu nombre de usuario de Last.FM.
•`/clearuser`: Elimina tu nombre de usuario de Last.FM del bot.
•`/lastfm`: Devuelve lo que estás buscando en Last.FM.
"""
__mod_name__ = "Last.FM"
SET_USER_HANDLER = CommandHandler("setuser",
set_user,
pass_args=True,
run_async=True)
CLEAR_USER_HANDLER = CommandHandler("clearuser", clear_user, run_async=True)
LASTFM_HANDLER = DisableAbleCommandHandler("lastfm", last_fm, run_async=True)
dispatcher.add_handler(SET_USER_HANDLER)
dispatcher.add_handler(CLEAR_USER_HANDLER)
dispatcher.add_handler(LASTFM_HANDLER)
ADD_CLEAN_BLUE_TEXT_GLOBAL_HANDLER = CommandHandler(
"gignoreblue", add_bluetext_ignore_global, run_async=True
)
REMOVE_CLEAN_BLUE_TEXT_GLOBAL_HANDLER = CommandHandler(
"ungignoreblue", remove_bluetext_ignore_global, run_async=True
)
LIST_CLEAN_BLUE_TEXT_HANDLER = CommandHandler(
"listblue", bluetext_ignore_list, run_async=True
)
CLEAN_BLUE_TEXT_HANDLER = MessageHandler(
Filters.command & Filters.chat_type.groups,
clean_blue_text_must_click,
run_async=True,
)
dispatcher.add_handler(SET_CLEAN_BLUE_TEXT_HANDLER)
dispatcher.add_handler(ADD_CLEAN_BLUE_TEXT_HANDLER)
dispatcher.add_handler(REMOVE_CLEAN_BLUE_TEXT_HANDLER)
dispatcher.add_handler(ADD_CLEAN_BLUE_TEXT_GLOBAL_HANDLER)
dispatcher.add_handler(REMOVE_CLEAN_BLUE_TEXT_GLOBAL_HANDLER)
dispatcher.add_handler(LIST_CLEAN_BLUE_TEXT_HANDLER)
dispatcher.add_handler(CLEAN_BLUE_TEXT_HANDLER, BLUE_TEXT_CLEAN_GROUP)
__mod_name__ = "Cleaner"
__handlers__ = [
SET_CLEAN_BLUE_TEXT_HANDLER,
ADD_CLEAN_BLUE_TEXT_HANDLER,
REMOVE_CLEAN_BLUE_TEXT_HANDLER,
ADD_CLEAN_BLUE_TEXT_GLOBAL_HANDLER,
REMOVE_CLEAN_BLUE_TEXT_GLOBAL_HANDLER,
LIST_CLEAN_BLUE_TEXT_HANDLER,
def __migrate__(old_chat_id, new_chat_id):
sql.migrate_chat(old_chat_id, new_chat_id)
__help__ = "" # no help string
BROADCAST_HANDLER = CommandHandler(
["broadcastall", "broadcastusers", "broadcastgroups"],
broadcast,
run_async=True)
USER_HANDLER = MessageHandler(Filters.all & Filters.chat_type.groups,
log_user,
run_async=True)
CHAT_CHECKER_HANDLER = MessageHandler(Filters.all & Filters.chat_type.groups,
chat_checker,
run_async=True)
CHATLIST_HANDLER = CommandHandler("groups", chats, run_async=True)
dispatcher.add_handler(USER_HANDLER, USERS_GROUP)
dispatcher.add_handler(BROADCAST_HANDLER)
dispatcher.add_handler(CHATLIST_HANDLER)
dispatcher.add_handler(CHAT_CHECKER_HANDLER, CHAT_GROUP)
__mod_name__ = "Users"
__handlers__ = [(USER_HANDLER, USERS_GROUP), BROADCAST_HANDLER,
CHATLIST_HANDLER]
__command_list__ = [
"broadcastall", "broadcastusers", "broadcastgroups", "groups"
]
wallpapers = json_rep.get("wallpapers")
if not wallpapers:
msg.reply_text("No se han encontrado resultados!")
return
else:
index = randint(0, len(wallpapers) - 1) # Choose random index
wallpaper = wallpapers[index]
wallpaper = wallpaper.get("url_image")
wallpaper = wallpaper.replace("\\", "")
bot.send_photo(
chat_id,
photo=wallpaper,
caption="Vista Previa",
reply_to_message_id=msg_id,
timeout=60,
)
bot.send_document(
chat_id,
document=wallpaper,
filename="wallpaper",
caption=caption,
reply_to_message_id=msg_id,
timeout=60,
)
__mod_name__ = "Wallpapers"
WALLPAPER_HANDLER = DisableAbleCommandHandler("wall", wall, run_async=True)
dispatcher.add_handler(WALLPAPER_HANDLER)
__command_list__ = ["wall"]
user_id,
chat.title,
chat.id,
excp.message,
)
message.reply_text(
"Bueno maldita sea, no puedo silenciar a ese usuario.")
return ""
__help__ = """
*Solo administradores:*
•`/mute <userhandle>`: Silencia a un usuario. También se puede utilizar respondiendo al usuario.
•`/tmute <userhandle> x (m/h/d)`: Silencia a un usuario por x tiempo. (a través del identificador o respuesta). `m`=`minutos`, `h`=`horas`, `d`=`días`.
•`/unmute <userhandle>`: Desilencia a un usuario. También se puede utilizar respondiendo al usuario.
"""
MUTE_HANDLER = CommandHandler("mute", mute, run_async=True)
UNMUTE_HANDLER = CommandHandler("unmute", unmute, run_async=True)
TEMPMUTE_HANDLER = CommandHandler(["tmute", "tempmute"],
temp_mute,
run_async=True)
dispatcher.add_handler(MUTE_HANDLER)
dispatcher.add_handler(UNMUTE_HANDLER)
dispatcher.add_handler(TEMPMUTE_HANDLER)
__mod_name__ = "Muteo"
__handlers__ = [MUTE_HANDLER, UNMUTE_HANDLER, TEMPMUTE_HANDLER]
replymsg = f"*Resultados de Speedtest:*[\u200c\u200c\u200e]({speedtest_image})"
speedtest_image = speed.results.share()
update.effective_message.edit_text(replymsg,
parse_mode=ParseMode.MARKDOWN)
msg.delete()
elif query.data == "speedtest_text":
replymsg = "*Resultados de Speedtest:*"
result = speed.results.dict()
replymsg += f"\nDescarga: `{convert(result['download'])}Mb/s`\nSubida: `{convert(result['upload'])}Mb/s`\nPing: `{result['ping']}`"
update.effective_message.edit_text(replymsg,
parse_mode=ParseMode.MARKDOWN)
else:
query.answer(
"Debes ser parte de la Asociación de Aventureros para usar este comando."
)
SPEED_TEST_HANDLER = DisableAbleCommandHandler("speedtest",
speedtestxyz,
run_async=True)
SPEED_TEST_CALLBACKHANDLER = CallbackQueryHandler(speedtestxyz_callback,
pattern="speedtest_.*")
dispatcher.add_handler(SPEED_TEST_HANDLER)
dispatcher.add_handler(SPEED_TEST_CALLBACKHANDLER)
__mod_name__ = "SpeedTest"
__command_list__ = ["speedtest"]
__handlers__ = [SPEED_TEST_HANDLER, SPEED_TEST_CALLBACKHANDLER]
data = message.reply_to_message.text
elif len(args) >= 1:
data = message.text.split(None, 1)[1]
else:
message.reply_text("Qué se supone que debo hacer con esto?")
return
key = (
requests.post("https://nekobin.com/api/documents", json={"content": data})
.json()
.get("result")
.get("key")
)
url = f"https://nekobin.com/{key}"
reply_text = f"Copiado a *Nekobin* : {url}"
message.reply_text(
reply_text, parse_mode=ParseMode.MARKDOWN, disable_web_page_preview=True
)
PASTE_HANDLER = DisableAbleCommandHandler("paste", paste, run_async=True)
dispatcher.add_handler(PASTE_HANDLER)
__command_list__ = ["paste"]
__handlers__ = [PASTE_HANDLER]
bot.send_message(int(chat_id), str(to_send))
except TelegramError:
update.effective_message.reply_text(
"No pude enviar el mensaje. ¿Tal vez no formo parte de ese grupo?"
)
INFO_HANDLER = DisableAbleCommandHandler("info",
info,
pass_args=True,
run_async=True)
STATS_HANDLER = CommandHandler("stats", stats, run_async=True)
ID_HANDLER = DisableAbleCommandHandler("id", get_id, run_async=True)
GIFID_HANDLER = DisableAbleCommandHandler("gifid", gifid, run_async=True)
SISINFO_HANDLER = CommandHandler("sinfo", sisinfo, run_async=True)
SNIPE_HANDLER = CommandHandler("snipe", snipe, run_async=True)
dispatcher.add_handler(INFO_HANDLER)
dispatcher.add_handler(STATS_HANDLER)
dispatcher.add_handler(ID_HANDLER)
dispatcher.add_handler(GIFID_HANDLER)
dispatcher.add_handler(SISINFO_HANDLER)
dispatcher.add_handler(SNIPE_HANDLER)
__mod_name__ = "Misceláneo"
__command_list__ = ["info", "id", "stats", "gifid", "sinfo", "snipe"]
__handlers__ = [
INFO_HANDLER, STATS_HANDLER, GIFID_HANDLER, ID_HANDLER, SISINFO_HANDLER,
SNIPE_HANDLER
]
•`/tban <usuario> x (m/h/d)`: Prohíbe (Banea) a un usuario durante el tiempo `x`. (a través del ID o respondiendo). `m` = `minutos`, `h` = `horas`, `d` = `días`.
•`/unban <usuario>`: Desbloquea a un usuario. (a través del ID o respondiendo)
•`/kick o /exploit <usuario>`: Saca a un usuario del grupo. (a través del ID o respondiendo)
"""
BAN_HANDLER = CommandHandler("ban", ban, run_async=True)
TEMPBAN_HANDLER = CommandHandler(["tban"], temp_ban, run_async=True)
EXPLOIT_HANDLER = CommandHandler(["exploit", "kick"], exploit, run_async=True)
UNBAN_HANDLER = CommandHandler("unban", unban, run_async=True)
ROAR_HANDLER = CommandHandler("roar", selfunban, run_async=True)
EXPLOITME_HANDLER = DisableAbleCommandHandler("exploitme",
exploitme,
filters=Filters.chat_type.groups,
run_async=True)
dispatcher.add_handler(BAN_HANDLER)
dispatcher.add_handler(TEMPBAN_HANDLER)
dispatcher.add_handler(EXPLOIT_HANDLER)
dispatcher.add_handler(UNBAN_HANDLER)
dispatcher.add_handler(ROAR_HANDLER)
dispatcher.add_handler(EXPLOITME_HANDLER)
__mod_name__ = "Bans"
__handlers__ = [
BAN_HANDLER,
TEMPBAN_HANDLER,
EXPLOIT_HANDLER,
UNBAN_HANDLER,
ROAR_HANDLER,
EXPLOITME_HANDLER,
]
__help__ = """
•`/rules`: Obtén las reglas del grupo.
*Solo administradores:*
•`/setrules <reglas aqui>`: Establece las reglas del grupo.
•`/clearrules`: Quita las reglas del grupo.
"""
__mod_name__ = "Reglas"
__command_list__ = ["rules", "setrules", "clearrules"]
GET_RULES_HANDLER = CommandHandler("rules",
get_rules,
filters=Filters.chat_type.groups,
run_async=True)
SET_RULES_HANDLER = CommandHandler("setrules",
set_rules,
filters=Filters.chat_type.groups,
run_async=True)
RESET_RULES_HANDLER = CommandHandler("clearrules",
clear_rules,
filters=Filters.chat_type.groups,
run_async=True)
dispatcher.add_handler(GET_RULES_HANDLER)
dispatcher.add_handler(SET_RULES_HANDLER)
dispatcher.add_handler(RESET_RULES_HANDLER)
"""
__mod_name__ = "Triggers"
FILTER_HANDLER = CommandHandler("settrigger", filters, run_async=False)
STOP_HANDLER = CommandHandler("deltrigger", stop_filter, run_async=False)
RMALLFILTER_HANDLER = CommandHandler("rmalltriggers",
rmall_filters,
filters=Filters.chat_type.groups)
RMALLFILTER_CALLBACK = CallbackQueryHandler(rmall_callback,
pattern=r"filters_.*")
LIST_HANDLER = DisableAbleCommandHandler("triggers",
list_handlers,
admin_ok=True)
CUST_FILTER_HANDLER = MessageHandler(
CustomFilters.has_text & ~Filters.update.edited_message, reply_filter)
dispatcher.add_handler(FILTER_HANDLER)
dispatcher.add_handler(STOP_HANDLER)
dispatcher.add_handler(LIST_HANDLER)
dispatcher.add_handler(CUST_FILTER_HANDLER, HANDLER_GROUP)
dispatcher.add_handler(RMALLFILTER_HANDLER)
dispatcher.add_handler(RMALLFILTER_CALLBACK)
__handlers__ = [
FILTER_HANDLER,
STOP_HANDLER,
LIST_HANDLER,
(CUST_FILTER_HANDLER, HANDLER_GROUP, RMALLFILTER_HANDLER),
]
message.reply_text(
"Bueno maldita sea, no puedo silenciar a ese usuario.")
RBAN_HANDLER = CommandHandler("rban",
rban,
filters=CustomFilters.sudo_filter,
run_async=True)
RUNBAN_HANDLER = CommandHandler("runban",
runban,
filters=CustomFilters.sudo_filter,
run_async=True)
RKICK_HANDLER = CommandHandler("rexploit",
rkick,
filters=CustomFilters.sudo_filter,
run_async=True)
RMUTE_HANDLER = CommandHandler("rmute",
rmute,
filters=CustomFilters.sudo_filter,
run_async=True)
RUNMUTE_HANDLER = CommandHandler("runmute",
runmute,
filters=CustomFilters.sudo_filter,
run_async=True)
dispatcher.add_handler(RBAN_HANDLER)
dispatcher.add_handler(RUNBAN_HANDLER)
dispatcher.add_handler(RKICK_HANDLER)
dispatcher.add_handler(RMUTE_HANDLER)
dispatcher.add_handler(RUNMUTE_HANDLER)
from time import sleep
from MeguRobot import dispatcher
from MeguRobot.modules.helper_funcs.chat_status import dev_plus
from telegram import TelegramError, Update
from telegram.ext import CallbackContext, CommandHandler
@dev_plus
def leave(update: Update, context: CallbackContext):
bot = context.bot
args = context.args
if args:
chat_id = str(args[0])
try:
bot.leave_chat(int(chat_id))
update.effective_message.reply_text("Beep boop, dejé ese grupo!.")
except TelegramError:
update.effective_message.reply_text(
"Beep boop, no pude dejar ese grupo (no sé por qué).")
else:
update.effective_message.reply_text("Envíame un ID de chat válido")
LEAVE_HANDLER = CommandHandler("leave", leave, run_async=True)
dispatcher.add_handler(LEAVE_HANDLER)
__mod_name__ = "Dev"
__handlers__ = [LEAVE_HANDLER]
if success:
msg.reply_text(
"Stickerpack creado correctamente. Puedes encontrarlo [aquÃ](https://t.me/addstickers/%s"
% packname,
parse_mode=ParseMode.MARKDOWN,
)
else:
msg.reply_text(
"No se pudo crear el paquete de Stickers. Posiblemente debido a la magia negra."
)
__help__ = """
•`/stickerid`: Responde a un sticker para decirte su ID de archivo.
•`/getsticker`: Responde a un sticker para subir su archivo PNG sin formato.
•`/steal`: Responde a un sticker para agregarlo a tu Stickerpack.
"""
__mod_name__ = "Stickers"
STICKERID_HANDLER = DisableAbleCommandHandler("stickerid", stickerid, run_async=True)
STICKERS_HANDLER = DisableAbleCommandHandler("stickers", cb_sticker, run_async=True)
GETSTICKER_HANDLER = DisableAbleCommandHandler("getsticker", getsticker, run_async=True)
STEAL_HANDLER = DisableAbleCommandHandler(
["steal", "kang"], steal, admin_ok=True, run_async=True
)
dispatcher.add_handler(STICKERID_HANDLER)
dispatcher.add_handler(STICKERS_HANDLER)
dispatcher.add_handler(GETSTICKER_HANDLER)
dispatcher.add_handler(STEAL_HANDLER)
friendly="afk",
run_async=True)
NO_AFK_HANDLER = DisableAbleMessageHandler(
Filters.all & Filters.chat_type.groups,
no_longer_afk,
friendly="afk",
)
AFK_REPLY_HANDLER = DisableAbleMessageHandler(
(Filters.entity(MessageEntity.MENTION)
| Filters.entity(MessageEntity.TEXT_MENTION)
| Filters.reply)
& Filters.chat_type.groups,
reply_afk,
friendly="afk",
)
dispatcher.add_handler(AFK_HANDLER, AFK_GROUP)
dispatcher.add_handler(AFK_REGEX_HANDLER, AFK_GROUP)
dispatcher.add_handler(NO_AFK_HANDLER, AFK_GROUP)
dispatcher.add_handler(AFK_REPLY_HANDLER, AFK_REPLY_GROUP)
__mod_name__ = "AFK"
__command_list__ = ["afk"]
__handlers__ = [
(AFK_HANDLER, AFK_GROUP),
(AFK_REGEX_HANDLER, AFK_GROUP),
(NO_AFK_HANDLER, AFK_GROUP),
(AFK_REPLY_HANDLER, AFK_REPLY_GROUP),
]
from MeguRobot import dispatcher
from MeguRobot.modules.disable import DisableAbleCommandHandler
from telegram import Update
from telegram.ext import CallbackContext
def shout(update: Update, context: CallbackContext):
args = context.args
text = " ".join(args)
result = []
result.append(" ".join([s for s in 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 + "```"
return update.effective_message.reply_text(msg, parse_mode="MARKDOWN")
SHOUT_HANDLER = DisableAbleCommandHandler("shout", shout, run_async=True)
dispatcher.add_handler(SHOUT_HANDLER)
__command_list__ = ["shout"]
__handlers__ = [SHOUT_HANDLER]
UNFROG_HANDLER = CommandHandler(("removefrog"), removefrog, run_async=True)
UNWHITELIST_HANDLER = CommandHandler(
("removewhitelist", "removegianttoad"), removewhitelist, run_async=True
)
WHITELISTLIST_HANDLER = CommandHandler(
["whitelistlist", "toads"], whitelistlist, run_async=True
)
FROGLIST_HANDLER = CommandHandler(["frogs"], froglist, run_async=True)
SUPPORTLIST_HANDLER = CommandHandler(
["supportlist", "demons"], supportlist, run_async=True
)
SUDOLIST_HANDLER = CommandHandler(["sudolist", "destroyers"], sudolist, run_async=True)
DEVLIST_HANDLER = CommandHandler(["devlist", "cardemons"], devlist, run_async=True)
dispatcher.add_handler(SUDO_HANDLER)
dispatcher.add_handler(SUPPORT_HANDLER)
dispatcher.add_handler(FROG_HANDLER)
dispatcher.add_handler(WHITELIST_HANDLER)
dispatcher.add_handler(UNSUDO_HANDLER)
dispatcher.add_handler(UNSUPPORT_HANDLER)
dispatcher.add_handler(UNFROG_HANDLER)
dispatcher.add_handler(UNWHITELIST_HANDLER)
dispatcher.add_handler(WHITELISTLIST_HANDLER)
dispatcher.add_handler(FROGLIST_HANDLER)
dispatcher.add_handler(SUPPORTLIST_HANDLER)
dispatcher.add_handler(SUDOLIST_HANDLER)
dispatcher.add_handler(DEVLIST_HANDLER)
__mod_name__ = "Aventureros"
El bloqueo de bots evitará que los no administradores agreguen bots al chat.
Nota:
• Desbloquear el permiso *info* permitirá a los miembros (no administradores) cambiar la información del grupo, como la descripción o el nombre del grupo
• Desbloquear el permiso *pin* permitirá a los miembros (no administradores) anclar un mensaje en un grupo
"""
__mod_name__ = "Bloqueos"
LOCKTYPES_HANDLER = DisableAbleCommandHandler("locktypes",
locktypes,
run_async=True)
LOCK_HANDLER = CommandHandler(
"lock", lock, pass_args=True,
run_async=True) # , filters=Filters.chat_types.groups)
UNLOCK_HANDLER = CommandHandler(
"unlock", unlock, pass_args=True,
run_async=True) # , filters=Filters.chat_types.groups)
LOCKED_HANDLER = CommandHandler(
"locks", list_locks,
run_async=True) # , filters=Filters.chat_types.groups)
dispatcher.add_handler(LOCK_HANDLER)
dispatcher.add_handler(UNLOCK_HANDLER)
dispatcher.add_handler(LOCKTYPES_HANDLER)
dispatcher.add_handler(LOCKED_HANDLER)
dispatcher.add_handler(
MessageHandler(Filters.all & Filters.chat_type.groups, del_lockables),
PERM_GROUP)
def load(update: Update, context: CallbackContext):
message = update.effective_message
text = message.text.split(" ", 1)[1]
load_messasge = message.reply_text(
f"Intentando cargar el módulo: <b>{text}</b>",
parse_mode=ParseMode.HTML)
try:
imported_module = importlib.import_module("MeguRobot.modules." + text)
except:
load_messasge.edit_text("Existe ese módulo?")
return
if not hasattr(imported_module, "__mod_name__"):
imported_module.__mod_name__ = imported_module.__name__
if not imported_module.__mod_name__.lower() in IMPORTED:
IMPORTED[imported_module.__mod_name__.lower()] = imported_module
else:
load_messasge.edit_text("Módulo ya cargado.")
return
if "__handlers__" in dir(imported_module):
handlers = imported_module.__handlers__
for handler in handlers:
if not isinstance(handler, tuple):
dispatcher.add_handler(handler)
else:
if isinstance(handler[0], collections.Callable):
callback, telethon_event = handler
telethn.add_event_handler(callback, telethon_event)
else:
handler_name, priority = handler
dispatcher.add_handler(handler_name, priority)
else:
IMPORTED.pop(imported_module.__mod_name__.lower())
load_messasge.edit_text("El módulo no se puede cargar.")
return
if hasattr(imported_module, "__help__") and imported_module.__help__:
HELPABLE[imported_module.__mod_name__.lower()] = imported_module
# Chats to migrate on chat_migrated events
if hasattr(imported_module, "__migrate__"):
MIGRATEABLE.append(imported_module)
if hasattr(imported_module, "__stats__"):
STATS.append(imported_module)
if hasattr(imported_module, "__user_info__"):
USER_INFO.append(imported_module)
if hasattr(imported_module, "__import_data__"):
DATA_IMPORT.append(imported_module)
if hasattr(imported_module, "__export_data__"):
DATA_EXPORT.append(imported_module)
if hasattr(imported_module, "__chat_settings__"):
CHAT_SETTINGS[imported_module.__mod_name__.lower()] = imported_module
if hasattr(imported_module, "__user_settings__"):
USER_SETTINGS[imported_module.__mod_name__.lower()] = imported_module
load_messasge.edit_text(
"Módulo cargado correctamente: <b>{}</b>".format(text),
parse_mode=ParseMode.HTML,
)
