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]
•`/clear <NombredeNota>`: Borrar nota con ese nombre.
*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"]
el mensaje se eliminará inmediatamente. A veces, una buena combinación es combinar esto con filtros de advertencia.
* NOTA:* las listas negras no afectan a los administradores de grupo.
•`/blacklist`: Ver las palabras actuales de la lista negra.
*Solo administradores:*
•`/addblacklist <triggers>`: Agrega un trigger a la lista negra. Cada línea se considera un trigger, por lo que el uso de \
las líneas le permitirán agregar múltiples activadores.
•`/unblacklist <triggers>`: Elimina los triggers de la lista negra. Aquí se aplica la misma lógica de nueva línea, por lo que puede eliminar \
múltiples disparadores a la vez.
•`/rmblacklist <triggers>`: Igual que arriba.
"""
BLACKLIST_HANDLER = DisableAbleCommandHandler("blacklist",
blacklist,
run_async=True)
ADD_BLACKLIST_HANDLER = CommandHandler("addblacklist",
add_blacklist,
run_async=True)
UNBLACKLIST_HANDLER = CommandHandler(["unblacklist", "rmblacklist"],
unblacklist,
run_async=True)
BLACKLIST_DEL_HANDLER = MessageHandler(
(Filters.text | Filters.command | Filters.sticker | Filters.photo)
& Filters.chat_type.groups,
del_blacklist,
run_async=True,
)
dispatcher.add_handler(BLACKLIST_HANDLER)
dispatcher.add_handler(ADD_BLACKLIST_HANDLER)
teks = await tr(text, targetlang="es")
return teks.text
__help__ = """
Obtén información sobre anime, manga o personajes de [AniList](anilist.co).
*Comandos disponibles:*
•`/anime <anime>`*:* Devuelve información sobre el anime.
•`/character <carácter>`*:* Devuelve información sobre el carácter.
•`/manga <manga>`*:* Devuelve información sobre el manga.
•`/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)
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)
res, parse_mode=ParseMode.MARKDOWN)
except:
res = "*@{}* está AFK desde hace {}.\n*Razón:* {}".format(
user_name, afk_time, user.reason)
update.effective_message.reply_text(
res, parse_mode=ParseMode.MARKDOWN)
__help__ = """
•`/afk <razón>`: Se marca como AFK (Lejos del Teclado).
•`brb <razón>`: Igual que el comando afk, pero no un comando.
Cuando se marca como AFK, cualquier mención será respondida con un mensaje para decirle que no está disponible.
"""
AFK_HANDLER = DisableAbleCommandHandler("afk", afk, run_async=True)
AFK_REGEX_HANDLER = DisableAbleMessageHandler(Filters.regex("(?i)brb"),
afk,
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,
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]
__help__ = """
• `/admins`: Lista de administradores en el chat
*Solo administradores:*
• `/pin`: Fija silenciosamente el mensaje al que respondió - agregue` 'loud'` o `' notify'` para dar notificaciones a los usuarios.
•`/unpin`: Quita el mensaje anclado actualmente.
•`/link`: Obtén el link del grupo.
•`/promote`: Promueve al usuario al que respondió.
•`/demote`: Rebaja al usuario al que respondió.
•`/title`: Establece un título personalizado para un administrador que promovió el bot.
•`/admincache`: Actúaliza la lista de administradores.
"""
ADMINLIST_HANDLER = DisableAbleCommandHandler("admins",
adminlist,
run_async=True)
PIN_HANDLER = CommandHandler("pin",
pin,
filters=Filters.chat_type.groups,
run_async=True)
UNPIN_HANDLER = CommandHandler("unpin",
unpin,
filters=Filters.chat_type.groups,
run_async=True)
INVITE_HANDLER = DisableAbleCommandHandler("link", invite, run_async=True)
PROMOTE_HANDLER = DisableAbleCommandHandler("promote", promote, run_async=True)
DEMOTE_HANDLER = DisableAbleCommandHandler("demote", demote, run_async=True)
__help__ = """
•`/runs`: Responde una cadena aleatoria de una matriz de respuestas.
•`/slap`: Abofetear a un usuario, o recibir una bofetada si no hay a quien reponder.
•`/shrug`: Shrugs XD.
•`/table`: Obtener flip/unflip.
•`/decide`: Responde aleatoriamente sí/no/tal vez.
•`/toss`: Lanza una moneda.
•`/dice`: Tira un dado.
•`/rlg`: Une oídos, nariz, boca y crea un emo ;-;
•`/weebify <text>`: Devuelve un texto weebify.
"""
WEEBIFY_HANDLER = DisableAbleCommandHandler("weebify", weebify, run_async=True)
RUNS_HANDLER = DisableAbleCommandHandler("runs", runs, run_async=True)
SLAP_HANDLER = DisableAbleCommandHandler("slap", slap, run_async=True)
TOSS_HANDLER = DisableAbleCommandHandler("toss", toss, run_async=True)
DICE_HANDLER = DisableAbleCommandHandler("dice", dice, run_async=True)
SHRUG_HANDLER = DisableAbleCommandHandler("shrug", shrug, run_async=True)
RLG_HANDLER = DisableAbleCommandHandler("rlg", rlg, run_async=True)
DECIDE_HANDLER = DisableAbleCommandHandler("decide", decide, run_async=True)
TABLE_HANDLER = DisableAbleCommandHandler("table", table, run_async=True)
dispatcher.add_handler(WEEBIFY_HANDLER)
dispatcher.add_handler(RUNS_HANDLER)
dispatcher.add_handler(SLAP_HANDLER)
dispatcher.add_handler(TOSS_HANDLER)
dispatcher.add_handler(DICE_HANDLER)
dispatcher.add_handler(SHRUG_HANDLER)
if member.status == "member":
query.answer("Solo el propietario del chat puede hacer esto.")
__help__ = """
A veces, puede confiar en que un usuario no enviará contenido no deseado. Tal vez no sea suficiente para convertirlos en administradores, pero es posible que no se apliquen bloqueos, listas negras y antiflood a ellos. Para eso están las liberaciones: libera a usuarios confiables para permitirles enviar.
*Comandos de administrador:*
•`/freestatus`: Verifica el estado de aprobación de un usuario en el chat actual.
•`/free`: Liberar a un usuario. Los bloqueos, las listas negras y el anti-flood ya no se les aplicarán.
•`/unfree`: Desaprobar a un usuario. Estará sujeto a bloqueos, listas negras y antiinundación nuevamente.
•`/freelist`: Lista todos los usuarios aprobados.
•`/unfreeall`: Quitar la libertad de *TODOS* los usuarios en un chat. Esto no se puede deshacer.
"""
APPROVE = DisableAbleCommandHandler("free",
approve,
filters=Filters.chat_type.groups)
DISAPPROVE = DisableAbleCommandHandler("unfree",
disapprove,
filters=Filters.chat_type.groups,
run_async=True)
APPROVED = DisableAbleCommandHandler("freelist",
approved,
filters=Filters.chat_type.groups,
run_async=True)
APPROVAL = DisableAbleCommandHandler("freestatus",
approval,
filters=Filters.chat_type.groups,
run_async=True)
UNAPPROVEALL = DisableAbleCommandHandler("unfreeall",
unapproveall,
`/setme Hola soy Megumin.`
`/me @nombredeusuario (por defecto es el tuyo si no hay un usuario especificado)`
*Información que otros agregan sobre tí:*
•`/bio`: Obtendrás tu biografía o la de otro usuario. Esto no lo puede configurar tú mismo.
•`/setbio <text>`: Mientras respondes, guardará la biografía de otro usuario.
Ejemplos:
`/bio @username (por defecto es el tuyo si no hay usuario especificado).`
`/setbio Este usuario es un lobo`(respondiendo al usuario)
*Información general sobre tí:*
•`/info`: Obtén información sobre un usuario(respondiendo al usuario, escribiendo su ID o alías)
•`/whois`: Obtén información sobre un usuario con información detallada.
"""
SET_BIO_HANDLER = DisableAbleCommandHandler("setbio",
set_about_bio,
run_async=True)
GET_BIO_HANDLER = DisableAbleCommandHandler("bio", about_bio, run_async=True)
STATS_HANDLER = CommandHandler("stats", stats, run_async=True)
ID_HANDLER = DisableAbleCommandHandler("id", get_id, run_async=True)
GIFID_HANDLER = DisableAbleCommandHandler("gifid", gifid, run_async=True)
INFO_HANDLER = DisableAbleCommandHandler(("info", "book"),
info,
run_async=True)
SET_ABOUT_HANDLER = DisableAbleCommandHandler("setme",
set_about_me,
run_async=True)
GET_ABOUT_HANDLER = DisableAbleCommandHandler("me", about_me, run_async=True)
"¡Se han encontrado páginas desambiguadas! Ajuste su busqueda en consecuencia.\n<i>{}</i>"
.format(e),
parse_mode=ParseMode.HTML,
)
except PageError as e:
update.message.reply_text("<code>{}</code>".format(e),
parse_mode=ParseMode.HTML)
if res:
result = f"<b>{search}</b>\n\n"
result += f"<i>{res}</i>\n"
result += f"""<a href="https://es.wikipedia.org/wiki/{search.replace(" ", "%20")}">Leer más...</a>"""
if len(result) > 4000:
with open("result.txt", "w") as f:
f.write(f"{result}\n\nUwU OwO OmO UmU")
with open("result.txt", "rb") as f:
context.bot.send_document(
document=f,
filename=f.name,
reply_to_message_id=update.message.message_id,
chat_id=update.effective_chat.id,
parse_mode=ParseMode.HTML,
)
else:
update.message.reply_text(result,
parse_mode=ParseMode.HTML,
disable_web_page_preview=True)
WIKI_HANDLER = DisableAbleCommandHandler("wiki", wiki, run_async=True)
dispatcher.add_handler(WIKI_HANDLER)
•`/wiki <query>`: Busca en Wikipedia
*Tiempo:*
•`/time <lugar>`: Da información sobre una zona horaria, 🕐 [Lista de Zonas Horarias](https://en.wikipedia.org/wiki/List_of_tz_database_time_zones).
*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)
WIKI_HANDLER = DisableAbleCommandHandler("wiki", wiki, run_async=True)
UD_HANDLER = DisableAbleCommandHandler("ud", ud, run_async=True)
CONVERTER_HANDLER = CommandHandler("cash", convert, run_async=True)
TIME_HANDLER = DisableAbleCommandHandler("time", gettime, run_async=True)
dispatcher.add_handler(SAY_HANDLER)
dispatcher.add_handler(WIKI_HANDLER)
dispatcher.add_handler(UD_HANDLER)
dispatcher.add_handler(MD_HELP_HANDLER)
dispatcher.add_handler(CONVERTER_HANDLER)
dispatcher.add_handler(TIME_HANDLER)
*Ejemplos:*
`/setme Hola soy Megumin.`
`/me @nombredeusuario (por defecto es el tuyo si no hay un usuario especificado)`
*Información que otros agregan sobre tí:*
•`/bio`: Obtendrás tu biografía o la de otro usuario. Esto no lo puedes configurar tú.
•`/setbio <text>`: Mientras respondes, guardará la biografía de otro usuario.
*Ejemplos:*
`/bio @username (por defecto es el tuyo si no hay usuario especificado).`
`/setbio Este usuario es un lobo`(respondiendo al usuario)
"""
SET_BIO_HANDLER = DisableAbleCommandHandler("setbio",
set_about_bio,
run_async=True)
GET_BIO_HANDLER = DisableAbleCommandHandler("bio", about_bio, run_async=True)
SET_ABOUT_HANDLER = DisableAbleCommandHandler("setme",
set_about_me,
run_async=True)
GET_ABOUT_HANDLER = DisableAbleCommandHandler("me", about_me, run_async=True)
dispatcher.add_handler(SET_BIO_HANDLER)
dispatcher.add_handler(GET_BIO_HANDLER)
dispatcher.add_handler(SET_ABOUT_HANDLER)
dispatcher.add_handler(GET_ABOUT_HANDLER)
__mod_name__ = "Info"
__command_list__ = [
•`/exploitme`: Explota(kickea) al usuario que emitió el comando.
*Solo administradores:*
•`/ban <usuario>`: Prohíbe (Banea) a un usuario. (a través del ID o respondiendo)
•`/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,
•`/nowarn <palabra clave>`*:* Detener el filtro de advertencia.
•`/warnlimit <número>` *:* Establece el lÃmite de advertencias.
•`/strongwarn <on/si/off/no>`*:* Si se activa, exceder el lÃmite de advertencia resultará en un ban. De lo contrario, solo kickeará.
"""
__mod_name__ = "Advertencias"
WARN_HANDLER = CommandHandler("warn",
warn_user,
filters=Filters.chat_type.groups)
RESET_WARN_HANDLER = CommandHandler(["resetwarn", "resetwarns"],
reset_warns,
filters=Filters.chat_type.groups)
CALLBACK_QUERY_HANDLER = CallbackQueryHandler(button, pattern=r"rm_warn")
MYWARNS_HANDLER = DisableAbleCommandHandler("warns",
warns,
filters=Filters.chat_type.groups)
ADD_WARN_HANDLER = CommandHandler("addwarn",
add_warn_filter,
filters=Filters.chat_type.groups)
RM_WARN_HANDLER = CommandHandler(["nowarn", "stopwarn"],
remove_warn_filter,
filters=Filters.chat_type.groups)
LIST_WARN_HANDLER = DisableAbleCommandHandler(
["warnlist", "warnfilters"],
list_warn_filters,
filters=Filters.chat_type.groups,
admin_ok=True,
)
WARN_FILTER_HANDLER = MessageHandler(
CustomFilters.has_text & Filters.chat_type.groups, reply_filter)
*Nota:* Los triggers también admiten markdown como: {firts}, {last}, etc. y botones.
¡Pon `/markdownhelp` para saber más!
"""
__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,
"(〜￣△￣)〜",
"(｢• ω •)｢",
"( ˘ ɜ˘) ♬♪♫",
"( o˘◡˘o) ┌iii┐",
"♨o(>_<)o♨",
"( ・・)つ―{}@{}@{}-",
"(*´з`)口ﾟ｡ﾟ口(・∀・ )",
"( *^^)o∀*∀o(^^* )",
"-●●●-ｃ(・・ )",
"(ﾉ≧∀≦)ﾉ ‥…━━━★",
"╰( ͡° ͜ʖ ͡° )つ──☆*:・ﾟ",
"(∩ᄑ_ᄑ)⊃━☆ﾟ*･｡*･:≡( ε:)",
]
def react(update: Update, context: CallbackContext):
message = update.effective_message
react = random.choice(reactions)
if message.reply_to_message:
message.reply_to_message.reply_text(react)
else:
message.reply_text(react)
REACT_HANDLER = DisableAbleCommandHandler("react", react)
dispatcher.add_handler(REACT_HANDLER)
__command_list__ = ["react"]
__handlers__ = [REACT_HANDLER]
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"]
"*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]
chat_id = str(args[0])
del args[0]
except TypeError:
update.effective_message.reply_text("Dame un chat!")
to_send = " ".join(args)
if len(to_send) >= 2:
try:
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"
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)
"<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]
*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,
]
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]
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]
Los bloqueos se pueden utilizar para restringir los usuarios de un grupo.
Por ejemplo:
El bloqueo de URL eliminará automáticamente todos los mensajes con URL, el bloqueo de stickers restringirá todos \
que los usuarios no administradores envíen stickers, etc.
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)
result = generate_time(query_timezone, ["zoneName", "countryName"])
if not result:
send_message.edit_text(
f"La información de zona horaria no está disponible para <b>{query}</b>\n"
'<b>Todas las zonas horarias:</b> <a href="https://en.wikipedia.org/wiki/List_of_tz_database_time_zones">Lista aquí</a>',
parse_mode=ParseMode.HTML,
disable_web_page_preview=True,
)
return
send_message.edit_text(result,
parse_mode=ParseMode.HTML,
disable_web_page_preview=True)
__help__ = """
•`/time <lugar>`: Da información sobre una zona horaria.
*Lugares disponibles:* Código de país/Nombre de país/Nombre de zona horaria.
• 🕐 [Lista de Zonas Horarias](https://en.wikipedia.org/wiki/List_of_tz_database_time_zones)
"""
TIME_HANDLER = DisableAbleCommandHandler("time", gettime, run_async=True)
dispatcher.add_handler(TIME_HANDLER)
__mod_name__ = "Tiempo"
__command_list__ = ["time"]
__handlers__ = [TIME_HANDLER]
