import glob
import os
try:
import instantmusic, subprocess
except:
os.system("pip install instantmusic")
os.system("rm -rf *.mp3")
def bruh(name):
os.system("instantmusic -q -s " + name)
@borg.on(admin_cmd(pattern="song ?(.*)"))
async def _(event):
if event.fwd_from:
return
DELAY_BETWEEN_EDITS = 0.3
PROCESS_RUN_TIME = 100
cmd = event.pattern_match.group(1)
reply_to_id = event.message.id
if event.reply_to_msg_id:
reply_to_id = event.reply_to_msg_id
await event.edit("ok finding the song")
bruh(str(cmd))
l = glob.glob("*.mp3")
loa = l[0]
await event.edit("sending song")
await borg.send_file(event.chat_id,
"""Get Detailed info about any message
Syntax: .json"""
from telethon import events
import io
from ethiopia.utils import admin_cmd
@borg.on(admin_cmd("json"))
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 borg.send_file(event.chat_id,
out_file,
force_document=True,
allow_cache=False,
reply_to=reply_to_id)
await event.delete()
else:
await event.edit("`{}`".format(the_real_message))
"""Get Administrators of any Chat*
Syntax: .get_admin"""
from telethon import events
from telethon.tl.types import ChannelParticipantsAdmins, ChannelParticipantAdmin, ChannelParticipantCreator
from ethiopia.utils import admin_cmd
@borg.on(admin_cmd("get_ad?(m)in ?(.*)"))
async def _(event):
if event.fwd_from:
return
mentions = "**Admins in this Channel**: \n"
should_mention_admins = False
reply_message = None
pattern_match_str = event.pattern_match.group(1)
if "m" in pattern_match_str:
should_mention_admins = True
if event.reply_to_msg_id:
reply_message = await event.get_reply_message()
input_str = event.pattern_match.group(2)
to_write_chat = await event.get_input_chat()
chat = None
if not input_str:
chat = to_write_chat
else:
mentions_heading = "Admins in {} channel: \n".format(input_str)
mentions = mentions_heading
try:
chat = await borg.get_entity(input_str)
except Exception as e:
await event.edit(str(e))
"""Emoji
Available Commands:
.ok"""
from telethon import events
import asyncio
from ethiopia.utils import admin_cmd
@borg.on(admin_cmd("(.*)"))
async def _(event):
if event.fwd_from:
return
animation_interval = 0.00001
animation_ttl = range(0, 90)
input_str = event.pattern_match.group(1)
if input_str == "ok":
await event.edit(input_str)
animation_chars = [
"F", "U", "C", "K", "Y", "O", "U", "B", "C", "FK", "UU", "FCUK",
"UOY", "C", "F", "Y", "F", "Ok Sar 😇"
]
for i in animation_ttl:
await asyncio.sleep(animation_interval)
await event.edit(animation_chars[i % 18])
"""Get information about an user on GitHub
Syntax: .github USERNAME"""
from telethon import events
import requests
from ethiopia.utils import admin_cmd
@borg.on(admin_cmd("github (.*)"))
async def _(event):
if event.fwd_from:
return
input_str = event.pattern_match.group(1)
url = "https://api.github.com/users/{}".format(input_str)
r = requests.get(url)
if r.status_code != 404:
b = r.json()
avatar_url = b["avatar_url"]
html_url = b["html_url"]
gh_type = b["type"]
name = b["name"]
company = b["company"]
blog = b["blog"]
location = b["location"]
bio = b["bio"]
created_at = b["created_at"]
await borg.send_file(event.chat_id,
caption="""Name: [{}]({})
Type: {}
Company: {}
Blog: {}
Location: {}
"""Pins the replied message
Syntax: .cpin [LOUD]"""
from telethon import events
from telethon.tl import functions, types
from ethiopia.utils import admin_cmd
@borg.on(admin_cmd("cpin ?(.*)"))
async def _(event):
if event.fwd_from:
return
silent = True
input_str = event.pattern_match.group(1)
if input_str:
silent = False
if event.message.reply_to_msg_id is not None:
message_id = event.message.reply_to_msg_id
try:
await borg(
functions.messages.UpdatePinnedMessageRequest(
event.chat_id, message_id, silent))
except Exception as e:
await event.edit(str(e))
else:
await event.delete()
else:
await event.edit(
"Reply to a message to pin the message in this Channel.")
"updating ..."
)
NEW_UP_DATE_FOUND = (
"New update found for {branch_name}\n"
"`**Updating**"
)
REPO_REMOTE_NAME = "temponame"
IFFUCI_ACTIVE_BRANCH_NAME = "master"
DIFF_MARKER = "HEAD..{remote_name}/{branch_name}"
NO_HEROKU_APP_CFGD = "no heroku application found, but a key given? 😕 "
HEROKU_GIT_REF_SPEC = "HEAD:refs/heads/master"
RESTARTING_APP = "re-starting heroku application"
# -- Constants End -- #
@borg.on(admin_cmd("update ?(.*)", outgoing=True))
async def updater(message):
try:
repo = git.Repo()
except git.exc.InvalidGitRepositoryError as e:
repo = git.Repo.init()
origin = repo.create_remote(REPO_REMOTE_NAME, OFFICIAL_UPSTREAM_REPO)
origin.fetch()
repo.create_head(IFFUCI_ACTIVE_BRANCH_NAME, origin.refs.master)
repo.heads.master.checkout(True)
active_branch_name = repo.active_branch.name
if active_branch_name != IFFUCI_ACTIVE_BRANCH_NAME:
await message.edit(IS_SELECTED_DIFFERENT_BRANCH.format(
branch_name=active_branch_name
))
# Adapted from OpenUserBot for Uniborg, X-tra-Telegram
"""Download & Upload Images on Telegram\n
Syntax: `.img <Name>` or `.img (replied message)`
\n Upgraded and Google Image Error Fixed by @NeoMatrix90 aka @kirito6969
"""
from ethiopia.googol_images import googleimagesdownload
import os
import shutil
from re import findall
from ethiopia.utils import admin_cmd
@borg.on(admin_cmd(pattern="img ?(.*)"))
async def img_sampler(event):
await event.edit("`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 event.edit(
"`um, mind mentioning what I actually need to search for ;_;`")
return
lim = findall(r"lim=\d+", query)
# lim = event.pattern_match.group(1)
try:
lim = lim[0]
lim = lim.replace("lim=", "")
"""Get Telegram Profile Picture and other information
Syntax: .whois @username"""
import html
from telethon.tl.functions.photos import GetUserPhotosRequest
from telethon.tl.functions.users import GetFullUserRequest
from telethon.tl.types import MessageEntityMentionName
from telethon.utils import get_input_location
from ethiopia.utils import admin_cmd
@borg.on(admin_cmd("whois ?(.*)"))
async def _(event):
if event.fwd_from:
return
replied_user, error_i_a = await get_full_user(event)
if replied_user is None:
await event.edit(str(error_i_a))
return False
replied_user_profile_photos = await borg(
GetUserPhotosRequest(user_id=replied_user.user.id,
offset=42,
max_id=0,
limit=80))
replied_user_profile_photos_count = "NaN"
try:
replied_user_profile_photos_count = replied_user_profile_photos.count
except AttributeError as e:
pass
user_id = replied_user.user.id
# some people have weird HTML in their names
"".format(str(e)),
reply_to=event.message.id,
silent=True
)
try:
await borg(
functions.account.UpdateProfileRequest( # pylint:disable=E0602
first_name=f"{ETHIO_NAME}",
last_name=""))
except Exception as e: # pylint:disable=C0103,W0703
await event.edit(str(e))
USER_AFK = {} # pylint:disable=E0602
afk_time = None # pylint:disable=E0602
@borg.on(admin_cmd(pattern=r"afk ?(.*)")) # pylint:disable=E0602
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)
me = await borg.get_me()
telname = (me.first_name)
telnm = (me.last_name)
if not USER_AFK: # pylint:disable=E0602
""" Get the Bots in any chat*
Syntax: .get_bot"""
from telethon import events
from telethon.tl.types import ChannelParticipantAdmin, ChannelParticipantsBots
from ethiopia.utils import admin_cmd
@borg.on(admin_cmd("bots ?(.*)"))
async def _(event):
if event.fwd_from:
return
mentions = "**Bots in this Channel**: \n"
input_str = event.pattern_match.group(1)
to_write_chat = await event.get_input_chat()
chat = None
if not input_str:
chat = to_write_chat
else:
mentions = "**Bots in {} group**: \n".format(input_str)
try:
chat = await borg.get_entity(input_str)
except Exception as e:
await event.edit(str(e))
return None
try:
async for x in borg.iter_participants(chat,
filter=ChannelParticipantsBots):
if isinstance(x.participant, ChannelParticipantAdmin):
mentions += "\n[{}](tg://user?id={}) `{}`".format(
x.first_name, x.id, x.id)
else:
"""Default Permission in Telegram 5.0.1
Available Commands: .lock <option>, .unlock <option>, .locks
API Options: msg, media, sticker, gif, gamee, ainline, gpoll, adduser, cpin, changeinfo
DB Options: bots, commands, email, forward, url"""
from telethon import events, functions, types
from ethiopia.ethiopia.sql_helper.locks_sql import update_lock, is_locked, get_locks
from ethiopia.utils import admin_cmd
@borg.on(admin_cmd("lock( (?P<target>\S+)|$)"))
async def _(event):
# Space weirdness in regex required because argument is optional and other
# commands start with ".lock"
if event.fwd_from:
return
input_str = event.pattern_match.group("target")
peer_id = event.chat_id
if input_str in (("bots", "commands", "email", "forward", "url")):
update_lock(peer_id, input_str, True)
await event.edit("Locked {}".format(input_str))
else:
msg = None
media = None
sticker = None
gif = None
gamee = None
ainline = None
gpoll = None
adduser = None
cpin = None
"""IX.IO pastebin like site
Syntax: .paste"""
from telethon import events
import asyncio
from datetime import datetime
import os
import requests
from ethiopia.utils import admin_cmd
def progress(current, total):
logger.info("Downloaded {} of {}\nCompleted {}".format(current, total, (current / total) * 100))
@borg.on(admin_cmd("paste ?(.*)"))
async def _(event):
if event.fwd_from:
return
start = datetime.now()
if not os.path.isdir(Config.TMP_DOWNLOAD_DIRECTORY):
os.makedirs(Config.TMP_DOWNLOAD_DIRECTORY)
input_str = event.pattern_match.group(1)
message = "SYNTAX: `.paste <long text to include>`"
if input_str:
message = input_str
elif event.reply_to_msg_id:
previous_message = await event.get_reply_message()
if previous_message.media:
downloaded_file_name = await borg.download_media(
previous_message,
Config.TMP_DOWNLOAD_DIRECTORY,
# Lots of lub to @r4v4n4 for gibing the base <3
import datetime
from telethon import events
from telethon.errors.rpcerrorlist import YouBlockedUserError
from telethon.tl.functions.account import UpdateNotifySettingsRequest
from ethiopia.utils import admin_cmd, register
@borg.on(admin_cmd("scan ?(.*)"))
async def _(event):
if event.fwd_from:
return
if not event.reply_to_msg_id:
await event.edit("```Reply to any user message.```")
return
reply_message = await event.get_reply_message()
if not reply_message.media:
await event.edit("```reply to a media message```")
return
chat = "@DrWebBot"
sender = reply_message.sender
if reply_message.sender.bot:
await event.edit("```Reply to actual users message.```")
return
await event.edit("**Scanning File**")
async with borg.conversation(chat) as conv:
try:
response = conv.wait_event(
events.NewMessage(incoming=True, from_users=161163358))
await borg.forward_messages(chat, reply_message)
response = await response
"""Get ID of any Telegram media, or any user
Syntax: .get_id"""
from telethon import events
from telethon.utils import pack_bot_file_id
from ethiopia.utils import admin_cmd
@borg.on(admin_cmd("id"))
async def _(event):
if event.fwd_from:
return
if event.reply_to_msg_id:
chat = await event.get_input_chat()
r_msg = await event.get_reply_message()
if r_msg.media:
bot_api_file_id = pack_bot_file_id(r_msg.media)
await event.edit(
"**Chat ID**: `{}`\n**User ID**: `{}`\n**Bot API File ID**: `{}`"
.format(str(event.chat_id), str(r_msg.from_id),
bot_api_file_id))
else:
await event.edit("**Chat ID**: `{}`\n**User ID**: `{}`".format(
str(event.chat_id), str(r_msg.from_id)))
else:
await event.edit("**Chat ID**: `{}`".format(str(event.chat_id)))