from typing import List import httpx from pyrogram import enums, filters from pyrogram.types import Message from androidrepo.database.magisk import create_magisk, get_magisk_by_branch from androidrepo.handlers.utils import get_changelog from androidrepo.handlers.utils.magisk import get_magisk, get_modules from ..androidrepo import AndroidRepo TYPES: List[str] = ["beta", "stable", "canary"] @AndroidRepo.on_message(filters.cmd("magisk")) async def on_magisk_m(c: AndroidRepo, m: Message): command = m.text.split()[0] m_type = m.text[len(command):] sm = await m.reply("Checking...") m_type = "stable" if len(m_type) < 1 else m_type[1:] m_type = m_type.lower() if m_type not in TYPES: await sm.edit(f"The version type '<b>{m_type}</b>' was not found.") return _magisk = await get_magisk_by_branch(branch=m_type) if _magisk is None:
from pyrogram.types import Message, User from androidrepo.config import STAFF_ID, SUDO_USERS from androidrepo.database.requests import ( create_request, delete_request, get_request_by_message_id, get_request_by_request_id, get_request_by_user_id, update_request, ) from ..androidrepo import AndroidRepo @AndroidRepo.on_message((filters.cmd("request ") | filters.regex("^#request "))) async def on_request_m(c: AndroidRepo, m: Message): if m.chat.type in (enums.ChatType.GROUP, enums.ChatType.SUPERGROUP): keyboard = [ [ ( "Go to PM!", f"http://t.me/{c.me.username}?start", "url", ) ] ] sent = await m.reply_text( "Please use this command in private.", reply_markup=c.ikb(keyboard), )
# This program is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as # published by the Free Software Foundation, either version 3 of the # License, or (at your option) any later version. # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. import os import sys from pyrogram import Client, filters from pyrogram.types import Message @Client.on_message(filters.sudo & filters.cmd('restart')) async def on_restart_m(c: Client, m: Message): await m.reply_text('Restarting...') os.execv(sys.executable, [sys.executable, '-m', 'hycon']) @Client.on_message(filters.sudo & filters.cmd('shutdown')) async def on_shutdown_m(c: Client, m: Message): await m.reply_text("Sleeping...") sys.exit()
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. from typing import Union from pyrogram import filters from pyrogram.types import CallbackQuery, Message from pyromod.helpers import ikb from amime.amime import Amime @Amime.on_message(filters.cmd(r"manga$") & filters.private) @Amime.on_callback_query(filters.regex(r"^manga$")) async def manga_start(bot: Amime, union: Union[CallbackQuery, Message]): is_callback = isinstance(union, CallbackQuery) message = union.message if is_callback else union lang = union._lang keyboard = [ [ (lang.suggestions_button, "suggestions manga 1"), (lang.categories_button, "categories manga 1"), ], [ (lang.upcoming_button, "upcoming manga 1"), (lang.favorites_button, "favorites manga 1"), ],
import asyncio import math from typing import Union import anilist from pyrogram import filters from pyrogram.types import CallbackQuery, InputMediaPhoto, Message from pyromod.helpers import array_chunk, ikb from amime.amime import Amime from amime.database import Episodes, Users from amime.modules.favorites import get_favorite_button from amime.modules.notify import get_notify_button @Amime.on_message(filters.cmd(r"anime (.+)")) @Amime.on_callback_query(filters.regex(r"^anime (\d+)\s?(\d+)?\s?(\d+)?")) async def anime_view(bot: Amime, union: Union[CallbackQuery, Message]): is_callback = isinstance(union, CallbackQuery) message = union.message if is_callback else union chat = message.chat user = union.from_user lang = union._lang is_private = await filters.private(bot, message) is_collaborator = await filters.collaborator( bot, union) or await filters.sudo(bot, union) query = union.matches[0].group(1) if is_callback:
"Esse é meu módulo de matemática, cuidado para não perder a cabeça.", "commands": {}, "help": True, } done_text: str = "<b>Expressão:</b> <code>{}</code>\n<b>Resultado:</b> <code>{}</code>" err_text: str = "Algo deu errado na requisição da API, tente novamente mais tarde..." url: str = "https://newton.now.sh/api/v2/{}/{}" def encoded(expression): return quote(expression, safe="") @Korone.on_message(filters.cmd("simplify (?P<calc>.+)", group=GROUP)) async def simplify_math(c: Korone, m: Message): calc = m.matches[0]["calc"] req = await http.get(url.format("simplify", encoded(calc))) if req.status_code == 200: r = req.json() else: await m.reply_text(err_text) return await m.reply_text((done_text).format(calc, r["result"])) @Korone.on_message(filters.cmd("factor (?P<calc>.+)", group=GROUP)) async def factor_math(c: Korone, m: Message): calc = m.matches[0]["calc"] req = await http.get(url.format("factor", encoded(calc)))
# SOFTWARE. import re from typing import Union from pyrogram import filters from pyrogram.types import CallbackQuery, Message from pyromod.helpers import ikb from amime.amime import Amime from amime.modules.anime.view import anime_view from amime.modules.character.view import character_view from amime.modules.manga.view import manga_view @Amime.on_message(filters.cmd(r"start$")) @Amime.on_callback_query(filters.regex(r"^start$")) async def start(bot: Amime, union: Union[CallbackQuery, Message]): is_callback = isinstance(union, CallbackQuery) message = union.message if is_callback else union user = union.from_user lang = union._lang if await filters.private(bot, message): await (message.edit_text if is_callback else message.reply_text)( lang.start_text_2.format( user_mention=user.mention(), bot_name=bot.me.first_name, ), reply_markup=ikb([ [
from .. import COMMANDS_HELP COMMANDS_HELP["misc"] = { "name": "Misc", "commands": { "user": { "id <user|reply>?": "Get (user|chat) id.", "info <user|reply>?": "Get a user info." } }, "text": "Here you can play a little with the miscellaneous section.", "help": True } @Client.on_message(filters.reply & filters.cmd('info$')) async def on_info_r_m(c: Client, m: Message): reply = m.reply_to_message user = reply.from_user await on_info_u(c, m, user) @Client.on_message(~filters.reply & filters.cmd('info$')) async def on_info_me_m(c: Client, m: Message): user = m.from_user await on_info_u(c, m, user) @Client.on_message(filters.cmd('info (?P<user>.+)')) async def on_info_m(c: Client, m: Message): user = m.matches[0]['user']
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. from typing import Dict, Union from pyrogram import filters from pyrogram.types import CallbackQuery, Message from pyromod.helpers import ikb from amime.amime import Amime from amime.config import CHANNELS, GROUPS @Amime.on_message(filters.cmd(r"about$")) @Amime.on_callback_query(filters.regex(r"^about$")) async def about(bot: Amime, union: Union[CallbackQuery, Message]): is_callback = isinstance(union, CallbackQuery) message = union.message if is_callback else union lang = union._lang kwargs: Dict = {} is_private = await filters.private(bot, message) if is_private and is_callback: keyboard = [ [ (lang.back_button, "start"), ], ]
from typing import List import httpx from pyrogram import enums, filters from pyrogram.types import Message from androidrepo.database.xposed import create_lsposed, get_lsposed_by_branch from androidrepo.handlers.utils import get_changelog from androidrepo.handlers.utils.xposed import get_lsposed from ..androidrepo import AndroidRepo TYPES: List[str] = ["riru", "zygisk"] @AndroidRepo.on_message(filters.cmd("lsposed")) async def lsposed(c: AndroidRepo, m: Message): command = m.text.split()[0] branch = m.text[len(command):] sm = await m.reply("Checking...") branch = "zygisk" if len(branch) < 1 else branch[1:] branch = branch.lower() if branch not in TYPES: await sm.edit(f"The version type '<b>{branch}</b>' was not found.") return _lsposed = await get_lsposed_by_branch(branch=branch) if _lsposed is None:
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. from typing import Union from pyrogram import filters from pyrogram.types import CallbackQuery, Message from pyromod.helpers import ikb from amime.amime import Amime @Amime.on_message(filters.cmd(r"anime$") & filters.private) @Amime.on_callback_query(filters.regex(r"^anime$")) async def anime_start(bot: Amime, union: Union[CallbackQuery, Message]): is_callback = isinstance(union, CallbackQuery) message = union.message if is_callback else union lang = union._lang keyboard = [ [ (lang.suggestions_button, "suggestions anime 1"), (lang.categories_button, "categories anime 1"), ], [ (lang.upcoming_button, "upcoming anime 1"), (lang.favorites_button, "favorites anime 1"), ],
import io import os import sys import traceback from typing import Dict import meval from pyrogram import filters from pyrogram.types import CallbackQuery, Message from pyromod.helpers import ikb from amime.amime import Amime from amime.utils import modules @Amime.on_message(filters.cmd(r"up(grad|dat)e$") & filters.sudo) async def upgrade_message(bot: Amime, message: Message): sent = await message.reply_text("Checking for updates...") await (await asyncio.create_subprocess_shell("git fetch origin")).communicate() proc = await asyncio.create_subprocess_shell( "git log HEAD..origin/main", stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.STDOUT, ) stdout = (await proc.communicate())[0].decode() if proc.returncode == 0: if len(stdout) > 0: changelog = "<b>Changelog</b>:\n"
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. import os import urllib import httpx import pendulum from pyrogram import filters from pyrogram.types import Document, InputMediaPhoto, Message, Video from pyromod.helpers import bki, ikb from amime.amime import Amime @Amime.on_message(filters.cmd(r"scan$") & filters.reply) async def anime_scan(bot: Amime, message: Message): reply = message.reply_to_message lang = message._lang if reply.from_user.id == bot.me.id: return if not reply.media: await message.reply_text(lang.media_not_found_text) return media = (reply.photo or reply.sticker or reply.animation or reply.document or reply.video) if isinstance(media, (Document, Video)):
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. from typing import Dict from pyrogram import filters from pyrogram.errors import PeerIdInvalid, UsernameInvalid, UsernameNotOccupied from pyrogram.types import CallbackQuery, Message from pyromod.helpers import array_chunk, ikb from amime.amime import Amime from amime.database import Collaborators, Episodes, Users, Viewed, Watched @Amime.on_message(filters.cmd(r"user")) async def user_view(bot: Amime, message: Message): reply = message.reply_to_message lang = message._lang me = message.from_user text = message.text query = text.split() if len(query) > 1: try: user = await bot.get_users(query[1]) except (PeerIdInvalid, UsernameInvalid, UsernameNotOccupied): await message.reply_text(lang.invalid_user + ".") return
try: if m.reply_to_message: if text in {"neko", "waifu"}: await m.reply_to_message.reply_photo(image_url) else: await m.reply_to_message.reply_document(image_url) elif text in {"neko", "waifu"}: await m.reply_photo(image_url) else: await m.reply_document(image_url) except BadRequest as e: await m.reply_text(f"<b>Erro!</b>\n<code>{e}</code>") return @Korone.on_message(filters.cmd(command="hug", action="Dar um abraço.", group=GROUP)) async def hug(c: Korone, m: Message): await neko_api(c, m, "hug") @Korone.on_message( filters.cmd(command="pat", action="Dar uma batida na cabeça.", group=GROUP) ) async def pat(c: Korone, m: Message): await neko_api(c, m, "pat") @Korone.on_message(filters.cmd(command="slap", action="Dar um tapa.", group=GROUP)) async def slap(c: Korone, m: Message): await neko_api(c, m, "slap")
import psutil import pyrogram from kantex.html import Bold, Code, KeyValueItem, Section from meval import meval from pyrogram import filters from pyrogram.errors import BadRequest from pyrogram.types import CallbackQuery, Message import korone from korone.config import OWNER from korone.korone import Korone from korone.utils import client_restart @Korone.on_message( filters.cmd("(sh(eel)?|term(inal)?) ") & filters.user(OWNER)) async def on_terminal_m(c: Korone, m: Message): command = m.text.split()[0] code = m.text[len(command) + 1:] sm = await m.reply_text("Running...") proc = await asyncio.create_subprocess_shell( code, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.STDOUT, ) stdout = (await proc.communicate())[0] lines = stdout.decode().split("\n") output = "".join(f"<code>{line}</code>\n" for line in lines) output_message = f"<b>Input\n></b> <code>{code}</code>\n\n" if len(output) > 0: if len(output) > (4096 - len(output_message)):
"commands": { "user": { "device <codename>": "Get information about the device and builds with such a code name (if it is officially maintained)." } }, "text": "This is the plugin where you can get data about the specific device.", "help": True } DEVICES_REPO = 'https://github.com/Hycon-Devices/official_devices/raw/master' BUILDS = {} @Client.on_message(filters.cmd('device (?P<codename>.+)')) async def on_device_m(c: Client, m: Message): codename = m.matches[0]['codename'] model = check_device(codename) if not model: await m.reply_text(text=f'The device <b>{codename}</b> was not found!') else: await get_device(m, model) def check_device(device: str) -> bool: response = requests.get(DEVICES_REPO + '/devices.json') models = json.loads(response.text) for model in models: if model['codename'] == device: return model
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. import asyncio from typing import Union import anilist from pyrogram import filters from pyrogram.types import CallbackQuery, Message from pyromod.helpers import ikb from amime.amime import Amime @Amime.on_message(filters.cmd(r"character (.+)")) @Amime.on_callback_query(filters.regex(r"^character (\d+)\s?(\d+)?\s?(\d+)?")) async def character_view(bot: Amime, union: Union[CallbackQuery, Message]): is_callback = isinstance(union, CallbackQuery) message = union.message if is_callback else union user = union.from_user lang = union._lang is_private = await filters.private(bot, message) query = union.matches[0].group(1) if is_callback: user_id = union.matches[0].group(2) if user_id is not None: user_id = int(user_id)
from amime.amime import Amime from amime.database import ( Chats, Collaborators, Episodes, Favorites, Reports, Requests, Users, Viewed, Watched, ) @Amime.on_message( filters.cmd(r"stats$") & (filters.collaborator | filters.sudo)) async def stats_view(bot: Amime, message: Message): lang = message._lang text = "<b>General statistics</b>" text += "\n <b>Database</b>:" text += f"\n <b>Size</b>: <code>{humanize.naturalsize(os.stat('amime/database/database.sqlite').st_size, binary=True)}</code>" disk = shutil.disk_usage("/") text += f"\n <b>Free</b>: <code>{humanize.naturalsize(disk[2], binary=True)}</code>" text += "\n <b>Episodes</b>:" episodes = await Episodes.all() text += f"\n <b>Total</b>: <code>{len(episodes)}</code>" for language in lang.strings.keys(): episodes = await Episodes.filter(language=language) text += f"\n <b>{language.upper()}</b>: <code>{len(episodes)}</code>" favorites = await Favorites.all()
hours, minutes = divmod(minutes, 60) days, hours = divmod(hours, 24) tmp = ( ((str(days) + " Dias, ") if days else "") + ((str(hours) + " Horas, ") if hours else "") + ((str(minutes) + " Minutos, ") if minutes else "") + ((str(seconds) + " Segundos, ") if seconds else "") + ((str(milliseconds) + " ms, ") if milliseconds else "") ) return tmp[:-2] @Korone.on_message( filters.cmd( command="anime (?P<search>.+)", action="Pesquise informações de animes pelo AniList.", group=GROUP, ) ) async def anilist_anime(c: Korone, m: Message): query = m.matches[0]["search"] if query.isdecimal(): anime_id = int(query) else: try: async with anilist.AsyncClient() as client: results = await client.search(query, "anime", page=1, limit=1) anime_id = results[0].id except IndexError: return await m.reply_text(
from korone.handlers.utils.reddit import bodyfetcher, imagefetcher, titlefetcher from korone.korone import Korone from korone.utils import http GROUP = "general" COMMANDS_HELP[GROUP] = { "name": "Diversos", "text": "Este é meu módulo de comandos sem categoria.", "commands": {}, "help": True, } @Korone.on_message( filters.cmd(command="ping", action="Verifique a velocidade de resposta do korone.")) async def ping(c: Korone, m: Message): first = datetime.now() sent = await m.reply_text("<b>Pong!</b>") second = datetime.now() time = (second - first).microseconds / 1000 await sent.edit_text(f"<b>Pong!</b> <code>{time}</code>ms") @Korone.on_message( filters.cmd( command=r"user(\s(?P<text>.+))?", action="Retorna algumas informações do usuário.", )) async def user_info(c: Korone, m: Message): args = m.matches[0]["text"]
from datetime import datetime import aiodown import humanize from pyrogram import filters from pyrogram.enums import ParseMode from pyrogram.errors import FloodWait, MessageIdInvalid, MessageNotModified from pyrogram.types import Message from androidrepo.androidrepo import AndroidRepo from androidrepo.config import LOGS_ID DOWNLOAD_DIR = "./downloads/" @AndroidRepo.on_message(filters.sudo & filters.cmd(r"reup (?P<query>.+)")) async def reupload(c: AndroidRepo, m: Message): file_url = m.matches[0]["query"] is_url = re.match(r"(http(s)?)?(://)?(www)?(\.)?(.*)\.(.*)", file_url) if not is_url: await m.reply_text("<b>Error:</b> Enter a valid URL.") return try: file_desc = await m.ask( "Send me the file description as markdown...", filters=filters.sudo, parse_mode=ParseMode.MARKDOWN, timeout=120, )
import httpx import rapidjson as json from httpx import TimeoutException from pyrogram import enums, filters from pyrogram.types import Message from androidrepo.utils import httpx_timeout from ..androidrepo import AndroidRepo API_HOST = "https://api.orangefox.download/v3" TYPES: List[str] = ["stable", "beta"] @AndroidRepo.on_message( filters.cmd("start ofox_(?P<args>.+)") & filters.private) async def orangefox_pm(c: AndroidRepo, m: Message): args = m.matches[0]["args"] await orangefox_list(c, m, args) @AndroidRepo.on_message(filters.cmd("ofox$")) @AndroidRepo.on_message(filters.cmd("ofox beta$")) async def orangefox_list(c: AndroidRepo, m: Message, build_type: str = None): if build_type is None: args = m.text.split(" ") if len(args) == 1: build_type = "stable" else: build_type = args[1]
# SPDX-License-Identifier: GPL-3.0 # Copyright (c) 2021-2022 Amano Team import httpx from bs4 import BeautifulSoup from pyrogram import filters from pyrogram.types import Message from androidrepo.utils import httpx_timeout from ..androidrepo import AndroidRepo @AndroidRepo.on_message(filters.cmd("twrp")) async def twrp(c: AndroidRepo, m: Message): command = m.text.split()[0] device = m.text[len(command):] if len(device) < 1: await m.reply_text("Use <code>/twrp (device)</code>.") return if len(device) > 1: device = device[1:] async with httpx.AsyncClient(http2=True, timeout=httpx_timeout, follow_redirects=True) as client: r = await client.get(f"https://eu.dl.twrp.me/{device}/") if r.status_code == 404: text = f"Couldn't find twrp downloads for <code>{device}</code>!"
GROUP = "utils" COMMANDS_HELP[GROUP] = { "name": "Utilidades", "text": "Este é meu módulo de comandos utilitários.", "commands": {}, "help": True, } tg = Telegraph() @Korone.on_message( filters.cmd( command="pypi (?P<search>.+)", action="Pesquisa de módulos no PyPI.", group=GROUP, ) ) async def pypi(c: Korone, m: Message): text = m.matches[0]["search"] r = await http.get(f"https://pypi.org/pypi/{text}/json") if r.status_code == 200: json = r.json() pypi_info = escape_definition(json["info"]) message = ( "<b>%s</b> Por <i>%s %s</i>\n" "Plataforma: <b>%s</b>\n" "Versão: <b>%s</b>\n" "Licença: <b>%s</b>\n" "Resumo: <b>%s</b>\n"
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. import os import re import urllib import bs4 import httpx from pyrogram import filters from pyrogram.types import Document, InputMediaPhoto, Message, Video from amime.amime import Amime @Amime.on_message(filters.cmd(r"reverse$") & filters.reply) async def reverse(bot: Amime, message: Message): reply = message.reply_to_message lang = message._lang if reply.from_user.id == bot.me.id: return if not reply.media: await message.reply_text(lang.media_not_found_text) return media = (reply.photo or reply.sticker or reply.animation or reply.document or reply.video) if isinstance(media, (Document, Video)):
from korone.korone import Korone from korone.utils import http GROUP = "spacex" COMMANDS_HELP[GROUP] = { "name": "SpaceX", "text": "Esse é meu módulo sobre a SpaceX.", "commands": {}, "help": True, } @Korone.on_message( filters.cmd(command="spacex$", action="Informações sobre a SpaceX.", group=GROUP)) async def spacex_wiki(c: Korone, m: Message): r = await http.get("https://api.spacexdata.com/v4/company") if r.status_code == 200: sx = r.json() else: await m.reply_text(f"<b>Erro!</b> <code>{r.status_code}</code>") return text = f"<u><b>{sx['name']}</b></u> 🚀" text += f"\n<b>Endereço:</b> {sx['headquarters']['address']}, {sx['headquarters']['city']}, {sx['headquarters']['state']}" text += f"\n<b>Fundador:</b> {sx['founder']}" text += f"\n<b>Fundada em:</b> {sx['founded']}" text += ("\n<b>Funcionários:</b> <code>{:,}</code>").format( sx["employees"])
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. import asyncio from pyrogram import filters from pyrogram.errors import FloodWait from pyrogram.types import Animation, Document, Message, Photo, Sticker, Video from amime.amime import Amime from amime.config import CHANNELS, CHATS from amime.database import Chats, Users @Amime.on_message( filters.cmd(r"alert (\w+) (\w+)") & (filters.collaborator | filters.sudo) & filters.chat(CHATS["staff"])) async def alert(bot: Amime, message: Message): reply = message.reply_to_message lang = message._lang to = message.matches[0].group(1) language = message.matches[0].group(2) media = message.photo or message.animation or message.document or message.video text = " ".join((message.text or message.caption).split()[3:]) if len(text) == 0: if bool(reply): media = (reply.photo or reply.sticker or reply.animation
Eu sou o <b>{}</b>, um bot interativo que adora participar de grupos! ^^ <b>Versão:</b> <code>{} ({})</code> """ about_text = """ 🚮 <b>{}</b> é um bot criado por diversão para o grupo <b>Spam-Therapy</b>. Seu foco é trazer funções legais e um design funcional com tecnologia e criatividade. 📦 Powered by <a href='https://docs.pyrogram.org/'>Pyrogram</a> with <a href='https://github.com/usernein/pyromod'>Pyromod</a>. 🗂 <b>Links:</b> <a href='{}'>GitHub</a> | <a href='{}'>Chat</a> """ @Korone.on_message( filters.cmd(command=r"start", action="Envia a mensagem de inicialização do bot.")) @Korone.on_callback_query(filters.regex(r"^start_back$")) async def start(c: Korone, m: Union[Message, CallbackQuery]): if isinstance(m, Message): query = m.text.split() if len(query) > 1: field = query[1] query = field.split("_") if query[0] == "help": module = query[1] await help_module(c, m, module) else: keyboard = [] text = (start_text).format( m.from_user.first_name, c.me.first_name,
# SPDX-License-Identifier: GPL-3.0 # Copyright (c) 2021-2022 Amano Team import html from typing import Union from pyrogram import enums, filters from pyrogram.types import CallbackQuery, Message from ..androidrepo import AndroidRepo @AndroidRepo.on_message(filters.cmd("start$")) @AndroidRepo.on_callback_query(filters.regex("^start_back$")) async def start(c: AndroidRepo, m: Union[Message, CallbackQuery]): keyboard = [] text = f"Hi <b>{html.escape(m.from_user.first_name)}</b>, I am the <b>official bot of the Android Repository channel</b>." keyboard.append([ ("💬 Group", "https://t.me/AndroidRepo_chat", "url"), ("📢 Channel", "https://t.me/AndroidRepo", "url"), ]) if isinstance(m, Message): if m.chat.type == enums.ChatType.PRIVATE: keyboard.append([("❔ Help", "help")]) else: keyboard.append([( "Click here for help!", f"http://t.me/{c.me.username}?start=help", "url", )]) await m.reply_text(