"""Invite the user(s) to the current chat Syntax: .invite <User(s)>""" from telethon import functions from jarvis.utils import j_cmd, edit_or_reply, sudo_cmd @jarvis.on(j_cmd(pattern="invite ?(.*)")) @jarvis.on(sudo_cmd(pattern="invite ?(.*)", allow_sudo=True)) async def _(event): if event.fwd_from: return to_add_users = event.pattern_match.group(1) if event.is_private: await edit_or_reply( event, "`.invite` users to a chat, not to a Private Message") else: logger.info(to_add_users) if not event.is_channel and event.is_group: # https://lonamiwebs.github.io/Telethon/methods/messages/add_chat_user.html for user_id in to_add_users.split(" "): try: await jarvis( functions.messages.AddChatUserRequest( chat_id=event.chat_id, user_id=user_id, fwd_limit=1000000)) except Exception as e: await edit_or_reply(event, str(e)) return
# credits: SNAPDRAGON (@s_n_a_p_s) import asyncio import time from jarvis.utils import j_cmd @jarvis.on( j_cmd( pattern= "webupload ?(.+?|) (?:--)(anonfiles|transfer|filebin|anonymousfiles|megaupload|bayfiles)" )) async def _(event): if event.fwd_from: return await event.edit("Processing ...") PROCESS_RUN_TIME = 100 input_str = event.pattern_match.group(1) selected_transfer = event.pattern_match.group(2) if input_str: file_name = input_str else: reply = await event.get_reply_message() file_name = await jarvis.download_media(reply.media, Var.TEMP_DOWNLOAD_DIRECTORY) event.message.id CMD_WEB = { "anonfiles": 'curl -F "file=@{}" https://anonfiles.com/api/upload', "transfer": 'curl --upload-file "{}" https://transfer.sh/{os.path.basename(file_name)}', "filebin":
from telethon import events from telethon.errors.rpcerrorlist import YouBlockedUserError from jarvis.utils import j_cmd, edit_or_reply, sudo_cmd @jarvis.on(j_cmd("mask ?(.*)", outgoing=True)) @jarvis.on(sudo_cmd("mask ?(.*)", allow_sudo=True)) async def _(event): if event.fwd_from: return if not event.reply_to_msg_id: await edit_or_reply(event, "```Reply to any user message.```") return reply_message = await event.get_reply_message() if not reply_message.media: await edit_or_reply(event, "```reply to text message```") return chat = "@hazmat_suit_bot" reply_message.sender if reply_message.sender.bot: await edit_or_reply(event, "```Reply to actual users message.```") return await edit_or_reply(event, "```Processing```") async with bot.conversation(chat) as conv: try: response = conv.wait_event( events.NewMessage(incoming=True, from_users=905164246)) await jarvis.send_message(chat, reply_message) response = await response except YouBlockedUserError:
"""Get Detailed info about any message Syntax: .json""" import io from jarvis.utils import j_cmd, edit_or_reply, sudo_cmd @jarvis.on(j_cmd("json", outgoing=True)) @jarvis.on(sudo_cmd("json", allow_sudo=True)) async def _(event): if event.fwd_from: return the_real_message = None reply_to_id = None if event.reply_to_msg_id: previous_message = await event.get_reply_message() the_real_message = previous_message.stringify() reply_to_id = event.reply_to_msg_id else: the_real_message = event.stringify() reply_to_id = event.message.id if len(the_real_message) > Config.MAX_MESSAGE_SIZE_LIMIT: with io.BytesIO(str.encode(the_real_message)) as out_file: out_file.name = "json.text" await jarvis.send_file( event.chat_id, out_file, force_document=True, allow_cache=False, reply_to=reply_to_id, )
name = event.raw_text snips = sql.get_chat_blacklist(event.chat_id) for snip in snips: pattern = r"( |^|[^\w])" + re.escape(snip) + r"( |$|[^\w])" if re.search(pattern, name, flags=re.IGNORECASE): try: await event.delete() except Exception: await edit_or_reply( event, "I do not have DELETE permission in this chat" ) sql.rm_from_blacklist(event.chat_id, snip.lower()) break @jarvis.on(j_cmd("addblacklist ((.|\n)*)", outgoing=True)) @jarvis.on(sudo_cmd("addblacklist ((.|\n)*)", allow_sudo=True)) async def on_add_black_list(event): text = event.pattern_match.group(1) to_blacklist = list( set(trigger.strip() for trigger in text.split("\n") if trigger.strip()) ) for trigger in to_blacklist: sql.add_to_blacklist(event.chat_id, trigger.lower()) await edit_or_reply( event, "Added {} triggers to the blacklist in the current chat".format( len(to_blacklist) ), )
"""Take screenshot of any website Syntax: .screenlong <Website URL>""" import io import traceback from datetime import datetime from selenium import webdriver from jarvis.utils import j_cmd, eor, sudo_cmd @jarvis.on(j_cmd("screenlong (.*)", outgoing=True)) @jarvis.on(sudo_cmd("screenlong (.*)", allow_sudo=True)) async def _(event): if event.fwd_from: return if Config.GOOGLE_CHROME_BIN is None: await eor(event, "need to install Google Chrome. Module Stopping.") return jevent = await eor(event, "Processing ...") start = datetime.now() try: chrome_options = webdriver.ChromeOptions() chrome_options.add_argument("--ignore-certificate-errors") chrome_options.add_argument("--test-type") chrome_options.add_argument("--headless") # https://stackoverflow.com/a/53073789/4723940 chrome_options.add_argument("--no-sandbox") chrome_options.add_argument("--disable-dev-shm-usage") chrome_options.binary_location = Config.GOOGLE_CHROME_BIN
"""Download & Upload Images on Telegram\n Syntax: `.img <Name>` or `.img (replied message)` \n Upgraded and Google Image Error Fixed """ import os import shutil from re import findall from jarvis.google_imgs import googleimagesdownload from jarvis.utils import j_cmd, edit_or_reply, sudo_cmd @jarvis.on(j_cmd(pattern="img ?(.*)", outgoing=True)) @jarvis.on(sudo_cmd(pattern="img ?(.*)", allow_sudo=True)) async def img_sampler(event): await edit_or_reply(event, "`Processing...`") reply = await event.get_reply_message() if event.pattern_match.group(1): query = event.pattern_match.group(1) elif reply: query = reply.message else: await edit_or_reply( event, "`um, mind mentioning what I actually need to search for ;_;`" ) return lim = findall(r"lim=\d+", query) # lim = event.pattern_match.group(1) try:
""" Google Text to Speech Available Commands: .tts LanguageCode as reply to a message .tts LangaugeCode | text to speak""" import asyncio import os import subprocess from datetime import datetime from gtts import gTTS from jarvis import CMD_HELP from jarvis.utils import j_cmd @jarvis.on(j_cmd(pattern="voice (.*)")) @jarvis.on(j_cmd(pattern="voice (.*)", allow_sudo=True)) async def _(event): if event.fwd_from: return input_str = event.pattern_match.group(1) start = datetime.now() if event.reply_to_msg_id: previous_message = await event.get_reply_message() text = previous_message.message lan = input_str elif "|" in input_str: lan, text = input_str.split("|") else: await event.reply("Invalid Syntax. Module stopping.") return
file_id = file_id[1:] return file_id async def get_file_name(content): file_name = "" c_append = False for c in str(content): if c == '"': c_append = True if c == ";": c_append = False if c_append: file_name = file_name + c file_name = file_name.replace('"', "") print("File Name: " + str(file_name)) return file_name @jarvis.on(j_cmd(pattern=r"gdl", outgoing=True)) @jarvis.on(sudo_cmd(pattern=r"gdl", allow_sudo=True)) async def g_download(event): if event.fwd_from: return drive_link = event.text[4:] print("Drive Link: " + drive_link) file_id = await get_id(drive_link) await edit_or_reply(event, "Downloading Requested File from G-Drive...") file_name = await download_file_from_google_drive(file_id) await event.edit("File Downloaded.\nName: `" + str(file_name) + "`")
# This Source Code Form is subject to the terms of the Mozilla Public # License, v. 2.0. If a copy of the MPL was not distributed with this # file, You can obtain one at http://mozilla.org/MPL/2 from telethon.tl.types import ChannelParticipantsAdmins from jarvis.utils import j_cmd @jarvis.on(j_cmd(pattern=r"tagall", outgoing=True)) @jarvis.on(j_cmd(pattern=r"tagall", allow_sudo=True)) async def _(event): if event.fwd_from: return mentions = "Tagging All Of You Guys !!! ❤️❤️❤️" chat = await event.get_input_chat() async for x in bot.iter_participants(chat, 100): mentions += f" \n [{x.first_name}](tg://user?id={x.id})" await event.reply(mentions) await event.delete() @jarvis.on(j_cmd(pattern=r"admin", outgoing=True)) @jarvis.on(j_cmd(pattern=r"admin", allow_sudo=True)) async def _(event): if event.fwd_from: return mentions = "Admins : " chat = await event.get_input_chat() async for x in bot.iter_participants(chat, filter=ChannelParticipantsAdmins): mentions += f" \n [{x.first_name}](tg://user?id={x.id})"
"口", "尸", "㔿", "尺", "丂", "丅", "凵", "リ", "山", "乂", "丫", "乙", ] @jarvis.on(j_cmd(pattern="weeb ?(.*)")) async def weebify(event): args = event.pattern_match.group(1) if not args: get = await event.get_reply_message() args = get.text if not args: await event.edit("`What I am Supposed to Weebify U Dumb`") return string = " ".join(args).lower() for normiecharacter in string: if normiecharacter in normiefont: weebycharacter = weebyfont[normiefont.index(normiecharacter)] string = string.replace(normiecharacter, weebycharacter) await event.edit(string)
# you may not use this file except in compliance with the License. # import io import os import os.path import time from os.path import exists, isdir from jarvis import CMD_HELP from jarvis.utils import j_cmd, eor, humanbytes, sudo_cmd MAX_MESSAGE_SIZE_LIMIT = 4095 @jarvis.on(j_cmd(outgoing=True, pattern=r"ls ?(.*)")) @jarvis.on(sudo_cmd(allow_sudo=True, pattern=r"ls ?(.*)")) async def lst(event): if event.fwd_from: return jeve = event.pattern_match.group(1) if jeve: path = jeve else: path = os.getcwd() if not exists(path): await eor( event, f"There is no such directory or file with the name `{jeve}` check again!", ) return
from random import randint from time import sleep from telethon.tl.types import ( ChannelParticipantAdmin, ChannelParticipantCreator, ChannelParticipantsAdmins, ChannelParticipantsBots, ) from telethon.utils import pack_bot_file_id from jarvis.utils import j_cmd, edit_or_reply, eor, sudo_cmd @jarvis.on(j_cmd(outgoing=True, pattern="random")) @jarvis.on(sudo_cmd(allow_sudo=True, pattern="random")) async def randomise(items): """ For .random command, get a random item from the list of items. """ if not items.text[0].isalpha() and items.text[0] not in ("/", "#", "@", "!"): itemo = (items.text[8:]).split() index = randint(1, len(itemo) - 1) await edit_or_reply( items, "**Query: **\n`" + items.text[8:] + "`\n**Output: **\n`" + itemo[index] + "`", )
import re import urllib import requests from bs4 import BeautifulSoup from PIL import Image from jarvis import CMD_HELP from jarvis.utils import j_cmd, eor, errors_handler, sudo_cmd opener = urllib.request.build_opener() useragent = "Mozilla/5.0 (Linux; Android 9; SM-G960F Build/PPR1.180610.011; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/74.0.3729.157 Mobile Safari/537.36" opener.addheaders = [("User-agent", useragent)] @jarvis.on(j_cmd(pattern=r"reverse(?: |$)(\d*)", outgoing=True)) @jarvis.on(sudo_cmd(pattern=r"reverse(?: |$)(\d*)", allow_sudo=True)) @errors_handler async def _(img): if os.path.isfile("okgoogle.png"): os.remove("okgoogle.png") message = await img.get_reply_message() if message and message.media: photo = io.BytesIO() await jarvis.download_media(message, photo) else: await eor(img, "`Reply to photo or sticker nigger.`") return if photo: jevent = await eor(img, "`Processing...`") try:
from jarvis import CMD_HELP from jarvis.jconfig import Config from jarvis.utils import j_cmd logging.basicConfig( format="%(asctime)s - %(name)s - %(levelname)s - %(message)s", level=logging.WARN) NO_PM_LOG_USERS = [] BOTLOG = True BOTLOG_CHATID = Config.PRIVATE_GROUP_BOT_API_ID @jarvis.on(j_cmd(outgoing=True, pattern=r"save(?: |$)([\s\S]*)")) async def log(log_text): """ For .log command, forwards a message or the command argument to the bot logs group """ if BOTLOG: if log_text.reply_to_msg_id: reply_msg = await log_text.get_reply_message() await reply_msg.forward_to(BOTLOG_CHATID) elif log_text.pattern_match.group(1): user = f"#LOG / Chat ID: {log_text.chat_id}\n\n" textx = user + log_text.pattern_match.group(1) await jarvis.send_message(BOTLOG_CHATID, textx) else: await log_text.edit("`What am I supposed to log?`") return await log_text.edit("`Logged Successfully`") else:
# Made By @DragSama with help of @TheRealPhoenix # Uses PokeApi.co """pokedex for pokemon info .berry for berry info .move for move info""" import requests from jarvis.utils import j_cmd, eor, sudo_cmd @jarvis.on(j_cmd(pattern="pokedex ?(.*)", outgoing=True)) @jarvis.on(sudo_cmd(pattern="pokedex ?(.*)", allow_sudo=True)) async def pokedex(event): string = event.pattern_match.group(1) url = "http://pokeapi.co/api/v2/pokemon/{}/".format(string) response = requests.get(url) if response.status_code == 200: data = response.json() msg = "" name = data.get("name") (data.get("abilities")[0].get("ability")) height = data.get("height") pokeid = data.get("id") (data.get("held_items")) sprites = data.get("sprites") sprites_front = sprites.get("front_default") weight = data.get("weight") types = data.get("types")[0].get("type") typesa = types.get("name") msg += "\n**Name** = {}".format(name) typecount = data.get("types") msg += "\n**ID** = {}".format(pokeid)
import asyncio from jarvis.utils import j_cmd # @command(pattern="^.cmds", outgoing=True) @jarvis.on(j_cmd(pattern=r"cmds")) async def install(event): if event.fwd_from: return cmd = "ls jarvis/plugins" process = await asyncio.create_subprocess_shell( cmd, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE) stdout, stderr = await process.communicate() o = stdout.decode() _o = o.split("\n") o = "\n".join(_o) OUTPUT = f"**List of Plugins:**\n{o}\n\n**HELP:** __If you want to know the commands for a plugin, do:-__ \n `.help <plugin name>` **without the < > brackets.**\n__All plugins might not work directly. Visit__ @jarvisot __for assistance.__" await event.edit(OUTPUT)
"""Quickly make a decision Syntax: .decide""" import requests from jarvis.utils import j_cmd, sudo_cmd @jarvis.on(j_cmd("decide", outgoing=True)) @jarvis.on(sudo_cmd("decide", allow_sudo=True)) async def _(event): if event.fwd_from: return message_id = event.message.id if event.reply_to_msg_id: message_id = event.reply_to_msg_id r = requests.get("https://yesno.wtf/api").json() await jarvis.send_message(event.chat_id, r["answer"], reply_to=message_id, file=r["image"]) await event.delete()
pack = COLLECTION_STRING[rnd] pc = requests.get("http://getwallpapers.com/collection/" + pack).text f = re.compile("/\w+/full.+.jpg") f = f.findall(pc) fy = "http://getwallpapers.com" + random.choice(f) print(fy) if not os.path.exists("f.ttf"): urllib.request.urlretrieve( "https://github.com/rebel6969/mym/raw/master/Rebel-robot-Regular.ttf", "f.ttf", ) urllib.request.urlretrieve(fy, "donottouch.jpg") @jarvis.on(j_cmd(pattern="avengersdp ?(.*)")) @jarvis.on(sudo_cmd(pattern="avengersdp ?(.*)", allow_sudo=True)) async def main(event): if event.fwd_from: return await edit_or_reply( event, "**Starting Avengers Profile Pic...\n\nDone ! Check Your DP By @JarvisOt**", ) while True: await animepp() file = await event.client.upload_file("donottouch.jpg") await event.client(functions.photos.UploadProfilePhotoRequest(file)) os.system("rm -rf donottouch.jpg") await asyncio.sleep(1000) # Edit this to your required needs
"""Fetch App Details from Playstore. .app <app_name> to fetch app details. .appr <app_name> to fetch app details with Xpl0iter request link.""" import bs4 import requests from jarvis.utils import j_cmd, sudo_cmd @jarvis.on(j_cmd(pattern="app (.*)")) @jarvis.on(sudo_cmd(pattern="app (.*)", allow_sudo=True)) async def apk(e): if event.fwd_from: return try: app_name = e.pattern_match.group(1) remove_space = app_name.split(" ") final_name = "+".join(remove_space) page = requests.get("https://play.google.com/store/search?q=" + final_name + "&c=apps") str(page.status_code) soup = bs4.BeautifulSoup(page.content, "lxml", from_encoding="utf-8") results = soup.findAll("div", "ZmHEEd") app_name = (results[0].findNext("div", "Vpfmgd").findNext( "div", "WsMG1c nnK0zc").text) app_dev = results[0].findNext("div", "Vpfmgd").findNext("div", "KoLSrc").text app_dev_link = ("https://play.google.com" + results[0].findNext( "div", "Vpfmgd").findNext("a", "mnKHRc")["href"]) app_rating = (results[0].findNext("div", "Vpfmgd").findNext(
"\U0001F780-\U0001F7FF" # Geometric Shapes Extended "\U0001F800-\U0001F8FF" # Supplemental Arrows-C "\U0001F900-\U0001F9FF" # Supplemental Symbols and Pictographs "\U0001FA00-\U0001FA6F" # Chess Symbols "\U0001FA70-\U0001FAFF" # Symbols and Pictographs Extended-A "\U00002702-\U000027B0" # Dingbats "]+") def deEmojify(inputString: str) -> str: """Remove emojis and other non-safe characters from string""" return re.sub(EMOJI_PATTERN, "", inputString) # @register(outgoing=True, pattern="^.waifu(?: |$)(.*)", allow_sudo=True)) @jarvis.on(j_cmd(pattern=r"waifu(?: |$)(.*)")) @jarvis.on(sudo_cmd(pattern=r"waifu(?: |$)(.*)", allow_sudo=True)) async def waifu(animu): if waifu.fwd_from: return # """Creates random anime sticker!""" text = animu.pattern_match.group(1) if not text: if animu.is_reply: text = (await animu.get_reply_message()).message else: await edit_or_reply( animu, "`You haven't written any article, Waifu is going away.`") return
import asyncio import os import textwrap from hachoir.metadata import extractMetadata from hachoir.parser import createParser from PIL import Image, ImageDraw, ImageFont from telethon.tl.types import DocumentAttributeFilename from jarvis import TEMP_DOWNLOAD_DIRECTORY from jarvis.utils import j_cmd, eor, sudo_cmd THUMB_IMAGE_PATH = "./jarvis.png" @jarvis.on(j_cmd(outgoing=True, pattern=r"mmf(?: |$)(.*)")) @jarvis.on(sudo_cmd(allow_sudo=True, pattern=r"mmf(?: |$)(.*)")) async def mim(event): if not event.reply_to_msg_id: await eor( event, "`Syntax: reply to an image with .mmf` 'text on top' ; 'text on bottom' ", ) return reply_message = await event.get_reply_message() if not reply_message.media: await eor(event, "```reply to a image/sticker/gif```") return await eor(event, "`Downloading Media..`") if reply_message.photo:
"api_url": "http://api.antiddos.systems", "username_colors": [ "#fb6169", "#faa357", "#b48bf2", "#85de85", "#62d4e3", "#65bdf3", "#ff5694", ], "default_username_color": "#b48bf2", } ) client = jarvis @jarvis.on(j_cmd(pattern="chat(.*)")) async def quotecmd(message): # noqa: C901 """Quote a message. Usage: .quote [template] If template is missing, possible templates are fetched.""" await message.delete() args = message.raw_text.split(" ")[1:] if args == []: args = ["default"] reply = await message.get_reply_message() if not reply: return await message.respond(strings["no_reply"]) if not args: return await message.respond(strings["no_template"])
"""use command .ducduckgo""" from jarvis.utils import j_cmd, edit_or_reply, sudo_cmd @jarvis.on(j_cmd("ducduckgo (.*)", outgoing=True)) @jarvis.on(sudo_cmd("ducduckgo (.*)", allow_sudo=True)) async def _(event): if event.fwd_from: return input_str = event.pattern_match.group(1) sample_url = "https://duckduckgo.com/?q={}".format( input_str.replace(" ", "+")) if sample_url: link = sample_url.rstrip() await edit_or_reply( event, "Let me 🦆 DuckDuckGo that for you:\n🔎 [{}]({})".format( input_str, link), ) else: await edit_or_reply(event, "something is wrong. please try again later.")
"#AfkLogger My Boss is Busy", ) except Exception as e: # pylint:disable=C0103,W0703 await jarvis.send_message( # pylint:disable=E0602 event.chat_id, "Please set `PLUGIN_CHANNEL` " + "for the proper functioning of afk functionality " + "in @JarvisSupportOT\n\n `{}`".format(str(e)), reply_to=event.message.id, silent=True, ) USER_AFK = {} # pylint:disable=E0602 afk_time = None # pylint:disable=E0602 @jarvis.on(j_cmd(pattern=r"afk ?(.*)")) @jarvis.on(sudo_cmd(pattern=r"afk ?(.*)", allow_sudo=True)) async def _(event): if event.fwd_from: return global USER_AFK # pylint:disable=E0602 global afk_time # pylint:disable=E0602 global last_afk_message # pylint:disable=E0602 global reason USER_AFK = {} afk_time = None last_afk_message = {} reason = event.pattern_match.group(1) if not USER_AFK: # pylint:disable=E0602 last_seen_status = await jarvis( # pylint:disable=E0602 functions.account.GetPrivacyRequest(
"""Color Plugin for @Jarvis Syntax: .color <color_code>""" import os from PIL import Image, ImageColor from jarvis.utils import j_cmd, edit_or_reply, sudo_cmd @jarvis.on(j_cmd(pattern="color (.*)", outgoing=True)) @jarvis.on(sudo_cmd(pattern="color (.*)", allow_sudo=True)) async def _(event): if event.fwd_from: return input_str = event.pattern_match.group(1) message_id = event.message.id if event.reply_to_msg_id: message_id = event.reply_to_msg_id if input_str.startswith("#"): try: usercolor = ImageColor.getrgb(input_str) except Exception as e: await edit_or_reply(event, str(e)) return False else: im = Image.new(mode="RGB", size=(1280, 720), color=usercolor) im.save("jarvis.png", "PNG") input_str = input_str.replace("#", "#COLOR_") await jarvis.send_file( event.chat_id, "jarvis.png",
snip.media_file_reference, ) else: media = None event.message.id if event.reply_to_msg_id: event.reply_to_msg_id await event.reply(snip.reply, file=media) if event.chat_id not in last_triggered_filters: last_triggered_filters[event.chat_id] = [] last_triggered_filters[event.chat_id].append(name) await asyncio.sleep(DELETE_TIMEOUT) last_triggered_filters[event.chat_id].remove(name) @jarvis.on(j_cmd(pattern="savefilter (.*)", outgoing=True)) @jarvis.on(sudo_cmd(pattern="savefilter (.*)", allow_sudo=True)) async def on_snip_save(event): name = event.pattern_match.group(1) msg = await event.get_reply_message() if msg: snip = {"type": TYPE_TEXT, "text": msg.message or ""} if msg.media: media = None if isinstance(msg.media, types.MessageMediaPhoto): media = utils.get_input_photo(msg.media.photo) snip["type"] = TYPE_PHOTO elif isinstance(msg.media, types.MessageMediaDocument): media = utils.get_input_document(msg.media.document) snip["type"] = TYPE_DOCUMENT if media:
import asyncio import time from telethon.errors import FloodWaitError from telethon.tl import functions from jarvis.utils import j_cmd, eor, sudo_cmd DEL_TIME_OUT = 60 @jarvis.on(j_cmd(pattern="bio")) # pylint:disable=E0602 @jarvis.on(sudo_cmd(pattern="bio", allow_sudo=True)) async def _(event): if event.fwd_from: return while True: DMY = time.strftime("%d.%m.%Y") HM = time.strftime("%H:%M:%S") bio = f"📅 {DMY} | User Of JarvisUserbot 😎 | ⌚️ {HM}" logger.info(bio) try: await jarvis( functions.account.UpdateProfileRequest( # pylint:disable=E0602 about=bio)) await eor(event, "Autobio Enabled !!") await asyncio.sleep(2) await event.delete() except FloodWaitError as ex: logger.warning(str(e)) await asyncio.sleep(ex.seconds)
from telethon.errors.rpcerrorlist import YouBlockedUserError from jarvis.utils import j_cmd, eor, sudo_cmd @jarvis.on(j_cmd("sg ?(.*)", outgoing=True)) @jarvis.on(sudo_cmd("sg ?(.*)", allow_sudo=True)) async def lastname(steal): if steal.fwd_from: return if not steal.reply_to_msg_id: await steal.edit("Reply to any user message.") return message = await steal.get_reply_message() chat = "@SangMataInfo_bot" user_id = message.sender.id id = f"/search_id {user_id}" if message.sender.bot: await steal.edit("Reply to actual users message.") return lol = await eor(steal, "Processingg !!!!!") try: async with bot.conversation(chat) as conv: try: msg = await conv.send_message(id) r = await conv.get_response() response = await conv.get_response() except YouBlockedUserError: await lol.edit("Please unblock @sangmatainfo_bot and try again" ) return
"""Emoji Available Commands: .supporthelp Credits to noone """ import asyncio from jarvis.utils import j_cmd @jarvis.on(j_cmd("supporthelp")) async def _(event): if event.fwd_from: return animation_interval = 0.1 animation_ttl = range(0, 36) # input_str = event.pattern_match.group(1) # if input_str == "support": await event.edit("for our support group") animation_chars = [ "Click here", "[Support Group](https://t.me/jarvissupportot)" ] for i in animation_ttl: await asyncio.sleep(animation_interval) await event.edit(animation_chars[i % 18])