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(
